rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This autocorrects percent literals
+    class PercentLiteralCorrector
+      include Util
+
+      attr_reader :config, :preferred_delimiters
+
+      def initialize(config, preferred_delimiters)
+        @config = config
+        @preferred_delimiters = preferred_delimiters
+      end
+
+      def correct(corrector, node, char)
+        escape = escape_words?(node)
+        char = char.upcase if escape
+        delimiters = delimiters_for("%#{char}")
+        contents = new_contents(node, escape, delimiters)
+        wrap_contents(corrector, node, contents, char, delimiters)
+      end
+
+      private
+
+      def wrap_contents(corrector, node, contents, char, delimiters)
+        corrector.replace(node, "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}")
+      end
+
+      def escape_words?(node)
+        node.children.any? { |w| needs_escaping?(w.children[0]) }
+      end
+
+      def delimiters_for(type)
+        PreferredDelimiters.new(type, config, preferred_delimiters).delimiters
+      end
+
+      def new_contents(node, escape, delimiters)
+        if node.multiline?
+          autocorrect_multiline_words(node, escape, delimiters)
+        else
+          autocorrect_words(node, escape, delimiters)
+        end
+      end
+
+      def autocorrect_multiline_words(node, escape, delimiters)
+        contents = process_multiline_words(node, escape, delimiters)
+        contents << end_content(node.source)
+        contents.join
+      end
+
+      def autocorrect_words(node, escape, delimiters)
+        node.children.map do |word_node|
+          fix_escaped_content(word_node, escape, delimiters)
+        end.join(' ')
+      end
+
+      def process_multiline_words(node, escape, delimiters)
+        base_line_num = node.first_line
+        prev_line_num = base_line_num
+        node.children.map.with_index do |word_node, index|
+          line_breaks = line_breaks(word_node, node.source, prev_line_num, base_line_num, index)
+          prev_line_num = word_node.last_line
+          content = fix_escaped_content(word_node, escape, delimiters)
+          line_breaks + content
+        end
+      end
+
+      def line_breaks(node, source, previous_line_num, base_line_num, node_index)
+        source_in_lines = source.split("\n")
+        if first_line?(node, previous_line_num)
+          node_index.zero? && node.first_line == base_line_num ? '' : ' '
+        else
+          process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        end
+      end
+
+      def first_line?(node, previous_line_num)
+        node.first_line == previous_line_num
+      end
+
+      def process_lines(node, previous_line_num, base_line_num, source_in_lines)
+        begin_line_num = previous_line_num - base_line_num + 1
+        end_line_num = node.first_line - base_line_num + 1
+        lines = source_in_lines[begin_line_num...end_line_num]
+        "\n#{lines.join("\n").split(node.source).first || ''}"
+      end
+
+      def fix_escaped_content(word_node, escape, delimiters)
+        content = +word_node.children.first.to_s
+        content = escape_string(content) if escape
+        substitute_escaped_delimiters(content, delimiters)
+        content
+      end
+
+      def substitute_escaped_delimiters(content, delimiters)
+        if delimiters.first != delimiters.last
+          # With different delimiters (eg. `[]`, `()`), if there are the same
+          # number of each, escaping is not necessary
+          delimiter_counts = delimiters.each_with_object({}) do |delimiter, counts|
+            counts[delimiter] = content.count(delimiter)
+          end
+
+          return content if delimiter_counts[delimiters.first] == delimiter_counts[delimiters.last]
+        end
+
+        delimiters.each { |delim| content.gsub!(delim, "\\#{delim}") }
+      end
+
+      def end_content(source)
+        result = /\A(\s*)\]/.match(source.split("\n").last)
+        "\n#{result[1]}" if result
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/punctuation_corrector.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This autocorrects punctuation
+    class PunctuationCorrector
+      class << self
+        def remove_space(corrector, space_before)
+          corrector.remove(space_before)
+        end
+
+        def add_space(corrector, token)
+          corrector.replace(token.pos, "#{token.pos.source} ")
+        end
+
+        def swap_comma(corrector, range)
+          return unless range
+
+          case range.source
+          when ',' then corrector.remove(range)
+          else          corrector.insert_after(range, ',')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/require_library_corrector.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class ensures a require statement is present for a standard library
+    # determined by the variable library_name
+    class RequireLibraryCorrector
+      extend RangeHelp
+
+      class << self
+        def correct(corrector, node, library_name)
+          node = node.parent while node.parent?
+          node = node.children.first if node.begin_type?
+          corrector.insert_before(node, require_statement(library_name))
+        end
+
+        def require_statement(library_name)
+          "require '#{library_name}'\n"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/space_corrector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This autocorrects whitespace
+    class SpaceCorrector
+      extend SurroundingSpace
+
+      class << self
+        attr_reader :processed_source
+
+        def empty_corrections(processed_source, corrector, empty_config,
+                              left_token, right_token)
+          @processed_source = processed_source
+          range = range_between(left_token.end_pos, right_token.begin_pos)
+          if offending_empty_space?(empty_config, left_token, right_token)
+            corrector.remove(range)
+            corrector.insert_after(left_token.pos, ' ')
+          elsif offending_empty_no_space?(empty_config, left_token, right_token)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          if left_token.space_after?
+            range = side_space_range(range: left_token.pos, side: :right)
+            corrector.remove(range)
+          end
+          return unless right_token.space_before?
+
+          range = side_space_range(range: right_token.pos, side: :left)
+          corrector.remove(range)
+        end
+
+        def add_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          corrector.insert_after(left_token.pos, ' ') unless left_token.space_after?
+          return if right_token.space_before?
+
+          corrector.insert_before(right_token.pos, ' ')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/string_literal_corrector.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This autocorrects string literals
+    class StringLiteralCorrector
+      extend Util
+
+      class << self
+        def correct(corrector, node, style)
+          return if node.dstr_type?
+
+          str = node.str_content
+          if style == :single_quotes
+            corrector.replace(node, to_string_literal(str))
+          else
+            corrector.replace(node, str.inspect)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/unused_arg_corrector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This autocorrects unused arguments.
+    class UnusedArgCorrector
+      extend RangeHelp
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(corrector, processed_source, node)
+          return if %i[kwarg kwoptarg].include?(node.type)
+
+          @processed_source = processed_source
+
+          if node.blockarg_type?
+            correct_for_blockarg_type(corrector, node)
+          else
+            variable_name = if node.optarg_type?
+                              node.node_parts[0]
+                            else
+                              # Extract only a var name without splat (`*`)
+                              node.source.gsub(/\A\*+/, '')
+                            end
+
+            corrector.replace(node.loc.name, "_#{variable_name}")
+          end
+        end
+
+        def correct_for_blockarg_type(corrector, node)
+          range = range_with_surrounding_space(node.source_range, side: :left)
+          range = range_with_surrounding_comma(range, :left)
+
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/documentation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Helpers for builtin documentation
+    module Documentation
+      module_function
+
+      # @api private
+      def department_to_basename(department)
+        "cops_#{department.to_s.downcase.tr('/', '_')}"
+      end
+
+      # @api private
+      def url_for(cop_class, config = nil)
+        base = department_to_basename(cop_class.department)
+        fragment = cop_class.cop_name.downcase.gsub(/[^a-z]/, '')
+        base_url = base_url_for(cop_class, config)
+        extension = extension_for(cop_class, config)
+
+        "#{base_url}/#{base}#{extension}##{fragment}" if base_url
+      end
+
+      # @api private
+      def base_url_for(cop_class, config)
+        if config
+          department_name = cop_class.department.to_s
+          url = config.for_department(department_name)['DocumentationBaseURL']
+          return url if url
+        end
+
+        default_base_url if builtin?(cop_class)
+      end
+
+      # @api private
+      def extension_for(cop_class, config)
+        if config
+          department_name = cop_class.department
+          extension = config.for_department(department_name)['DocumentationExtension']
+          return extension if extension
+        end
+
+        default_extension
+      end
+
+      # @api private
+      def default_base_url
+        'https://docs.rubocop.org/rubocop'
+      end
+
+      # @api private
+      def default_extension
+        '.html'
+      end
+
+      # @api private
+      def builtin?(cop_class)
+        # any custom method will do
+        return false unless (m = cop_class.instance_methods(false).first)
+
+        path, _line = cop_class.instance_method(m).source_location
+        path.start_with?(__dir__)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/exclude_limit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Allows specified configuration options to have an exclude limit
+  # ie. a maximum value tracked that it can be used by `--auto-gen-config`.
+  module ExcludeLimit
+    # Sets up a configuration option to have an exclude limit tracked.
+    # The parameter name given is transformed into a method name (eg. `Max`
+    # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
+    def exclude_limit(parameter_name, method_name: transform(parameter_name))
+      define_method(:"#{method_name}=") do |value|
+        cfg = config_to_allow_offenses
+        cfg[:exclude_limit] ||= {}
+        current_max = cfg[:exclude_limit][parameter_name]
+        value = [current_max, value].max if current_max
+        cfg[:exclude_limit][parameter_name] = value
+      end
+    end
+
+    private
+
+    def transform(parameter_name)
+      parameter_name.gsub(/(?<!\A)(?=[A-Z])/, '_').downcase
+    end
+  end
+end

data/lib/rubocop/cop/force.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A scaffold for concrete forces.
+    class Force
+      # @api private
+      class HookError < StandardError
+        attr_reader :joining_cop
+
+        def initialize(joining_cop)
+          super
+          @joining_cop = joining_cop
+        end
+      end
+
+      attr_reader :cops
+
+      def self.all
+        @all ||= []
+      end
+
+      def self.inherited(subclass)
+        super
+        all << subclass
+      end
+
+      def self.force_name
+        name.split('::').last
+      end
+
+      def initialize(cops)
+        @cops = cops
+      end
+
+      def name
+        self.class.force_name
+      end
+
+      def run_hook(method_name, *args)
+        cops.each do |cop|
+          next unless cop.respond_to?(method_name)
+
+          cop.public_send(method_name, *args)
+        rescue StandardError
+          raise HookError, cop
+        end
+      end
+
+      def investigate(_processed_source)
+        # Do custom processing and invoke #run_hook at arbitrary timing.
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/add_runtime_dependency.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Prefer `add_dependency` over `add_runtime_dependency` as the latter is
+      # considered soft-deprecated.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency('rubocop')
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency('rubocop')
+      #   end
+      #
+      class AddRuntimeDependency < Base
+        extend AutoCorrector
+
+        MSG = 'Use `add_dependency` instead of `add_runtime_dependency`.'
+
+        RESTRICT_ON_SEND = %i[add_runtime_dependency].freeze
+
+        def on_send(node)
+          return if !node.receiver || node.arguments.empty?
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'add_dependency')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/dependency_version.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Enforce that gem dependency version specifications or a commit reference (branch,
+      # ref, or tag) are either required or forbidden.
+      #
+      # @example EnforcedStyle: required (default)
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      # @example EnforcedStyle: forbidden
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'parser'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_development_dependency 'parser'
+      #   end
+      #
+      class DependencyVersion < Base
+        include ConfigurableEnforcedStyle
+        include GemspecHelp
+
+        REQUIRED_MSG = 'Dependency version specification is required.'
+        FORBIDDEN_MSG = 'Dependency version specification is forbidden.'
+        VERSION_SPECIFICATION_REGEX = /^\s*[~<>=]*\s*[0-9.]+/.freeze
+
+        ADD_DEPENDENCY_METHODS = %i[
+          add_dependency add_runtime_dependency add_development_dependency
+        ].freeze
+        RESTRICT_ON_SEND = ADD_DEPENDENCY_METHODS
+
+        # @!method add_dependency_method_declaration?(node)
+        def_node_matcher :add_dependency_method_declaration?, <<~PATTERN
+          (send
+            (lvar #match_block_variable_name?) #add_dependency_method? ...)
+        PATTERN
+
+        # @!method includes_version_specification?(node)
+        def_node_matcher :includes_version_specification?, <<~PATTERN
+          (send _ #add_dependency_method? <(str #version_specification?) ...>)
+        PATTERN
+
+        # @!method includes_commit_reference?(node)
+        def_node_matcher :includes_commit_reference?, <<~PATTERN
+          (send _ #add_dependency_method? <(hash <(pair (sym {:branch :ref :tag}) (str _)) ...>) ...>)
+        PATTERN
+
+        def on_send(node)
+          return unless add_dependency_method_declaration?(node)
+          return if allowed_gem?(node)
+
+          if offense?(node)
+            add_offense(node)
+            opposite_style_detected
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def allowed_gem?(node)
+          allowed_gems.include?(node.first_argument.str_content)
+        end
+
+        def allowed_gems
+          Array(cop_config['AllowedGems'])
+        end
+
+        def message(_range)
+          if required_style?
+            REQUIRED_MSG
+          elsif forbidden_style?
+            FORBIDDEN_MSG
+          end
+        end
+
+        def match_block_variable_name?(receiver_name)
+          gem_specification(processed_source.ast) do |block_variable_name|
+            return block_variable_name == receiver_name
+          end
+        end
+
+        def add_dependency_method?(method_name)
+          ADD_DEPENDENCY_METHODS.include?(method_name)
+        end
+
+        def offense?(node)
+          required_offense?(node) || forbidden_offense?(node)
+        end
+
+        def required_offense?(node)
+          return false unless required_style?
+
+          !includes_version_specification?(node) && !includes_commit_reference?(node)
+        end
+
+        def forbidden_offense?(node)
+          return false unless forbidden_style?
+
+          includes_version_specification?(node) || includes_commit_reference?(node)
+        end
+
+        def forbidden_style?
+          style == :forbidden
+        end
+
+        def required_style?
+          style == :required
+        end
+
+        def version_specification?(expression)
+          expression.match?(VERSION_SPECIFICATION_REGEX)
+        end
+      end
+    end
+  end
+end