rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that constants defined in classes and modules have
+      # an explicit visibility declaration. By default, Ruby makes all class-
+      # and module constants public, which litters the public API of the
+      # class or module. Explicitly declaring a visibility makes intent more
+      # clear, and prevents outside actors from touching private state.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     BAR = 42
+      #     BAZ = 43
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     BAR = 42
+      #     private_constant :BAR
+      #
+      #     BAZ = 43
+      #     public_constant :BAZ
+      #   end
+      #
+      # @example IgnoreModules: false (default)
+      #   # bad
+      #   class Foo
+      #     MyClass = Struct.new()
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     MyClass = Struct.new()
+      #     public_constant :MyClass
+      #   end
+      #
+      # @example IgnoreModules: true
+      #   # good
+      #   class Foo
+      #     MyClass = Struct.new()
+      #   end
+      #
+      class ConstantVisibility < Base
+        MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
+              'either `#public_constant` or `#private_constant`.'
+
+        def on_casgn(node)
+          return unless class_or_module_scope?(node)
+          return if visibility_declaration?(node)
+          return if ignore_modules? && module?(node)
+
+          add_offense(node, message: format(MSG, constant_name: node.name))
+        end
+
+        private
+
+        def ignore_modules?
+          cop_config.fetch('IgnoreModules', false)
+        end
+
+        def module?(node)
+          node.expression.class_constructor?
+        end
+
+        def class_or_module_scope?(node)
+          return false unless node.parent
+
+          case node.parent.type
+          when :begin
+            class_or_module_scope?(node.parent)
+          when :class, :module
+            true
+          end
+        end
+
+        def visibility_declaration?(node)
+          node.parent.each_child_node(:send).any? do |child|
+            visibility_declaration_for?(child, node.name)
+          end
+        end
+
+        # @!method visibility_declaration_for?(node, const_name)
+        def_node_matcher :visibility_declaration_for?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
+        PATTERN
+
+        def match_name?(name, constant_name)
+          name.to_sym == constant_name.to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check that a copyright notice was given in each source file.
+      #
+      # The default regexp for an acceptable copyright notice can be found in
+      # config/default.yml. The default can be changed as follows:
+      #
+      # [source,yaml]
+      # ----
+      # Style/Copyright:
+      #   Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      # ----
+      #
+      # This regex string is treated as an unanchored regex. For each file
+      # that RuboCop scans, a comment that matches this regex must be found or
+      # an offense is reported.
+      #
+      class Copyright < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Include a copyright notice matching /%<notice>s/ before any code.'
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in your RuboCop config'
+
+        def on_new_investigation
+          return if notice.empty? || notice_found?(processed_source)
+
+          verify_autocorrect_notice!
+          message = format(MSG, notice: notice)
+          if processed_source.blank?
+            add_global_offense(message)
+          else
+            offense_range = source_range(processed_source.buffer, 1, 0)
+            add_offense(offense_range, message: message) do |corrector|
+              autocorrect(corrector)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector)
+          token = insert_notice_before(processed_source)
+          range = token.nil? ? range_between(0, 0) : token.pos
+
+          corrector.insert_before(range, "#{autocorrect_notice}\n")
+        end
+
+        def notice
+          cop_config['Notice']
+        end
+
+        def autocorrect_notice
+          cop_config['AutocorrectNotice']
+        end
+
+        def verify_autocorrect_notice!
+          if autocorrect_notice.nil? || autocorrect_notice.empty?
+            raise Warning, "#{cop_name}: #{AUTOCORRECT_EMPTY_WARNING}"
+          end
+
+          regex = Regexp.new(notice)
+          return if autocorrect_notice.gsub(/^# */, '').match?(regex)
+
+          message = "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          raise Warning, "#{cop_name}: #{message}"
+        end
+
+        def insert_notice_before(processed_source)
+          token_index = 0
+          token_index += 1 if shebang_token?(processed_source, token_index)
+          token_index += 1 if encoding_token?(processed_source, token_index)
+          processed_source.tokens[token_index]
+        end
+
+        def shebang_token?(processed_source, token_index)
+          return false if token_index >= processed_source.tokens.size
+
+          token = processed_source.tokens[token_index]
+          token.comment? && /\A#!.*\z/.match?(token.text)
+        end
+
+        def encoding_token?(processed_source, token_index)
+          return false if token_index >= processed_source.tokens.size
+
+          token = processed_source.tokens[token_index]
+          token.comment? && /\A#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
+        end
+
+        def notice_found?(processed_source)
+          notice_regexp = Regexp.new(notice.lines.map(&:strip).join)
+          multiline_notice = +''
+          processed_source.tokens.each do |token|
+            break unless token.comment?
+
+            multiline_notice << token.text.sub(/\A# */, '')
+
+            break if notice_regexp.match?(token.text)
+          end
+
+          multiline_notice.match?(notice_regexp)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
+      #
+      # @example
+      #   # bad
+      #   class Person < Data.define(:first_name, :last_name)
+      #     def age
+      #       42
+      #     end
+      #   end
+      #
+      #   # good
+      #   Person = Data.define(:first_name, :last_name) do
+      #     def age
+      #       42
+      #     end
+      #   end
+      class DataInheritance < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = "Don't extend an instance initialized by `Data.define`. " \
+              'Use a block to customize the class.'
+
+        minimum_target_ruby_version 3.2
+
+        def on_class(node)
+          return unless data_define?(node.parent_class)
+
+          add_offense(node.parent_class) do |corrector|
+            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
+        end
+
+        # @!method data_define?(node)
+        def_node_matcher :data_define?, <<~PATTERN
+          {(send (const {nil? cbase} :Data) :define ...)
+           (block (send (const {nil? cbase} :Data) :define ...) ...)}
+        PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
+          elsif (class_node = parent.parent).body.nil?
+            corrector.remove(range_for_empty_class_body(class_node, parent))
+          else
+            corrector.insert_after(parent, ' do')
+          end
+        end
+
+        def range_for_empty_class_body(class_node, data_define)
+          if class_node.single_line?
+            range_between(data_define.source_range.end_pos, class_node.source_range.end_pos)
+          else
+            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for consistent usage of the `DateTime` class over the
+      # `Time` class. This cop is disabled by default since these classes,
+      # although highly overlapping, have particularities that make them not
+      # replaceable in certain situations when dealing with multiple timezones
+      # and/or DST.
+      #
+      # @safety
+      #   Autocorrection is not safe, because `DateTime` and `Time` do not have
+      #   exactly the same behavior, although in most cases the autocorrection
+      #   will be fine.
+      #
+      # @example
+      #
+      #   # bad - uses `DateTime` for current time
+      #   DateTime.now
+      #
+      #   # good - uses `Time` for current time
+      #   Time.now
+      #
+      #   # bad - uses `DateTime` for modern date
+      #   DateTime.iso8601('2016-06-29')
+      #
+      #   # good - uses `Time` for modern date
+      #   Time.iso8601('2016-06-29')
+      #
+      #   # good - uses `DateTime` with start argument for historical date
+      #   DateTime.iso8601('1751-04-23', Date::ENGLAND)
+      #
+      # @example AllowCoercion: false (default)
+      #
+      #   # bad - coerces to `DateTime`
+      #   something.to_datetime
+      #
+      #   # good - coerces to `Time`
+      #   something.to_time
+      #
+      # @example AllowCoercion: true
+      #
+      #   # good
+      #   something.to_datetime
+      #
+      #   # good
+      #   something.to_time
+      class DateTime < Base
+        extend AutoCorrector
+
+        CLASS_MSG = 'Prefer `Time` over `DateTime`.'
+        COERCION_MSG = 'Do not use `#to_datetime`.'
+
+        # @!method date_time?(node)
+        def_node_matcher :date_time?, <<~PATTERN
+          (call (const {nil? (cbase)} :DateTime) ...)
+        PATTERN
+
+        # @!method historic_date?(node)
+        def_node_matcher :historic_date?, <<~PATTERN
+          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
+        PATTERN
+
+        # @!method to_datetime?(node)
+        def_node_matcher :to_datetime?, <<~PATTERN
+          (call _ :to_datetime)
+        PATTERN
+
+        def on_send(node)
+          return unless date_time?(node) || (to_datetime?(node) && disallow_coercion?)
+          return if historic_date?(node)
+
+          message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+        alias on_csend on_send
+
+        private
+
+        def disallow_coercion?
+          !cop_config['AllowCoercion']
+        end
+
+        def autocorrect(corrector, node)
+          return if to_datetime?(node)
+
+          corrector.replace(node.receiver.loc.name, 'Time')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for parentheses in the definition of a method,
+      # that does not take any arguments. Both instance and
+      # class/singleton methods are checked.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo()
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   def foo() = do_something
+      #
+      #   # good
+      #   def foo = do_something
+      #
+      #   # good (without parentheses it's a syntax error)
+      #   def foo() do_something end
+      #
+      #   # bad
+      #   def Baz.foo()
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def Baz.foo
+      #     do_something
+      #   end
+      class DefWithParentheses < Base
+        extend AutoCorrector
+
+        MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
+
+        def on_def(node)
+          return if node.single_line? && !node.endless?
+          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+
+          add_offense(node_arguments) do |corrector|
+            corrector.remove(node_arguments)
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for chained `dig` calls that can be collapsed into a single `dig`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
+      # @example
+      #   # bad
+      #   x.dig(:foo).dig(:bar).dig(:baz)
+      #   x.dig(:foo, :bar).dig(:baz)
+      #   x.dig(:foo, :bar)&.dig(:baz)
+      #
+      #   # good
+      #   x.dig(:foo, :bar, :baz)
+      #
+      #   # good - `dig`s cannot be combined
+      #   x.dig(:foo).bar.dig(:baz)
+      #
+      class DigChain < Base
+        extend AutoCorrector
+        include CommentsHelp
+        include DigHelp
+
+        MSG = 'Use `%<replacement>s` instead of chaining.'
+        RESTRICT_ON_SEND = %i[dig].freeze
+
+        def on_send(node)
+          return if ignored_node?(node)
+          return unless node.loc.dot
+          return unless dig?(node)
+
+          range, arguments = inspect_chain(node)
+          return if invalid_arguments?(arguments)
+          return unless range
+
+          register_offense(node, range, arguments)
+        end
+        alias on_csend on_send
+
+        private
+
+        # Walk up the method chain while the receiver is `dig` with arguments.
+        def inspect_chain(node)
+          arguments = node.arguments.dup
+          end_range = node.source_range.end
+
+          while dig?(node = node.receiver)
+            begin_range = node.loc.selector
+            arguments.unshift(*node.arguments)
+            ignore_node(node)
+          end
+
+          return unless begin_range
+
+          [begin_range.join(end_range), arguments]
+        end
+
+        def invalid_arguments?(arguments)
+          # If any of the arguments are arguments forwarding (`...`), it can only be the
+          # first argument, or else the resulting code will have a syntax error.
+
+          return false unless arguments&.any?
+
+          forwarded_args_index = arguments.index(&:forwarded_args_type?)
+          forwarded_args_index && forwarded_args_index < (arguments.size - 1)
+        end
+
+        def register_offense(node, range, arguments)
+          arguments = arguments.map(&:source).join(', ')
+          replacement = "dig(#{arguments})"
+
+          add_offense(range, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(range, replacement)
+
+            comments_in_range(node).reverse_each do |comment|
+              corrector.insert_before(node, "#{comment.source}\n")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where the `#\_\_dir\_\_` method can replace more
+      # complex constructs to retrieve a canonicalized absolute path to the
+      # current file.
+      #
+      # @example
+      #   # bad
+      #   path = File.expand_path(File.dirname(__FILE__))
+      #
+      #   # bad
+      #   path = File.dirname(File.realpath(__FILE__))
+      #
+      #   # good
+      #   path = __dir__
+      class Dir < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.0
+
+        MSG = "Use `__dir__` to get an absolute path to the current file's directory."
+        RESTRICT_ON_SEND = %i[expand_path dirname].freeze
+
+        # @!method dir_replacement?(node)
+        def_node_matcher :dir_replacement?, <<~PATTERN
+          {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
+           (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}
+        PATTERN
+
+        def on_send(node)
+          dir_replacement?(node) do
+            add_offense(node) do |corrector|
+              corrector.replace(node, '__dir__')
+            end
+          end
+        end
+
+        private
+
+        def file_keyword?(node)
+          node.str_type? && node.source_range.is?('__FILE__')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `Dir.empty?('path/to/dir')` when checking if a directory is empty.
+      #
+      # @example
+      #   # bad
+      #   Dir.entries('path/to/dir').size == 2
+      #   Dir.children('path/to/dir').empty?
+      #   Dir.children('path/to/dir').size == 0
+      #   Dir.each_child('path/to/dir').none?
+      #
+      #   # good
+      #   Dir.empty?('path/to/dir')
+      #
+      class DirEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<replacement>s` instead.'
+        RESTRICT_ON_SEND = %i[== != > empty? none?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send (send (send $(const {nil? cbase} :Dir) :entries $_) :size) {:== :!= :>} (int 2))
+            (send (send (send $(const {nil? cbase} :Dir) :children $_) :size) {:== :!= :>} (int 0))
+            (send (send $(const {nil? cbase} :Dir) :children $_) :empty?)
+            (send (send $(const {nil? cbase} :Dir) :each_child $_) :none?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
+            add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          '!' if %i[!= >].include? node.method_name
+        end
+      end
+    end
+  end
+end