rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of a single string formatting utility.
+      # Valid options include `Kernel#format`, `Kernel#sprintf`, and `String#%`.
+      #
+      # The detection of `String#%` cannot be implemented in a reliable
+      # manner for all cases, so only two scenarios are considered -
+      # if the first argument is a string literal and if the second
+      # argument is an array literal.
+      #
+      # Autocorrection will be applied when using argument is a literal or known built-in conversion
+      # methods such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`, and `to_sym` on variables,
+      # provided that their return value is not an array. For example, when using `to_s`,
+      # `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # '%s' % [1, 2, 3]        #=> '1'
+      # format('%s', [1, 2, 3]) #=> '[1, 2, 3]'
+      # '%s' % [1, 2, 3].to_s   #=> '[1, 2, 3]'
+      # ----
+      #
+      # @example EnforcedStyle: format (default)
+      #   # bad
+      #   puts sprintf('%10s', 'foo')
+      #   puts '%10s' % 'foo'
+      #
+      #   # good
+      #   puts format('%10s', 'foo')
+      #
+      # @example EnforcedStyle: sprintf
+      #   # bad
+      #   puts format('%10s', 'foo')
+      #   puts '%10s' % 'foo'
+      #
+      #   # good
+      #   puts sprintf('%10s', 'foo')
+      #
+      # @example EnforcedStyle: percent
+      #   # bad
+      #   puts format('%10s', 'foo')
+      #   puts sprintf('%10s', 'foo')
+      #
+      #   # good
+      #   puts '%10s' % 'foo'
+      #
+      class FormatString < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Favor `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
+
+        # Known conversion methods whose return value is not an array.
+        AUTOCORRECTABLE_METHODS = %i[to_d to_f to_h to_i to_r to_s to_sym].freeze
+
+        # @!method formatter(node)
+        def_node_matcher :formatter, <<~PATTERN
+          {
+            (send nil? ${:sprintf :format} _ _ ...)
+            (send {str dstr} $:% ... )
+            (send !nil? $:% {array hash})
+          }
+        PATTERN
+
+        # @!method variable_argument?(node)
+        def_node_matcher :variable_argument?, <<~PATTERN
+          (send {str dstr} :% #autocorrectable?)
+        PATTERN
+
+        def on_send(node)
+          formatter(node) do |selector|
+            detected_style = selector == :% ? :percent : selector
+
+            return if detected_style == style
+
+            add_offense(node.loc.selector, message: message(detected_style)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def autocorrectable?(node)
+          return true if node.lvar_type?
+
+          node.send_type? && !AUTOCORRECTABLE_METHODS.include?(node.method_name)
+        end
+
+        def message(detected_style)
+          format(MSG, prefer: method_name(style), current: method_name(detected_style))
+        end
+
+        def method_name(style_name)
+          style_name == :percent ? 'String#%' : style_name
+        end
+
+        def autocorrect(corrector, node)
+          return if variable_argument?(node)
+
+          case node.method_name
+          when :%
+            autocorrect_from_percent(corrector, node)
+          when :format, :sprintf
+            case style
+            when :percent
+              autocorrect_to_percent(corrector, node)
+            when :format, :sprintf
+              corrector.replace(node.loc.selector, style.to_s)
+            end
+          end
+        end
+
+        def autocorrect_from_percent(corrector, node)
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
+                 else
+                   percent_rhs.source
+                 end
+
+          corrected = "#{style}(#{node.receiver.source}, #{args})"
+
+          corrector.replace(node, corrected)
+        end
+
+        def autocorrect_to_percent(corrector, node)
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
+
+          args = if param_args.one?
+                   format_single_parameter(param_args.last)
+                 else
+                   "[#{param_args.map(&:source).join(', ')}]"
+                 end
+
+          corrector.replace(node, "#{format} % #{args}")
+        end
+
+        def format_single_parameter(arg)
+          source = arg.source
+          return "{ #{source} }" if arg.hash_type?
+
+          arg.send_type? && arg.operator_method? && !arg.parenthesized? ? "(#{source})" : source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a consistent style for tokens within a format string.
+      #
+      # By default, all strings are evaluated. In some cases, this may be undesirable,
+      # as they could be used as arguments to a method that does not consider
+      # them to be tokens, but rather other identifiers or just part of the string.
+      #
+      # `AllowedMethods` or `AllowedPatterns` can be configured with in order to mark specific
+      # methods as always allowed, thereby avoiding an offense from the cop. By default, there
+      # are no allowed methods.
+      #
+      # Additionally, the cop can be made conservative by configuring it with
+      # `Mode: conservative` (default `aggressive`). In this mode, tokens (regardless
+      # of `EnforcedStyle`) are only considered if used in the format string argument to the
+      # methods `printf`, `sprintf`, `format` and `%`.
+      #
+      # NOTE: Tokens in the `unannotated` style (eg. `%s`) are always treated as if
+      # configured with `Conservative: true`. This is done in order to prevent false positives,
+      # because this format is very similar to encoded URLs or Date/Time formatting strings.
+      #
+      # @example EnforcedStyle: annotated (default)
+      #
+      #   # bad
+      #   format('%{greeting}', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #   format('%<greeting>s', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: template
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #   format('%{greeting}', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: unannotated
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%{greeting}', greeting: 'Hello')
+      #
+      #   # good
+      #   format('%s', 'Hello')
+      #
+      # It is allowed to contain unannotated token
+      # if the number of them is less than or equals to
+      # `MaxUnannotatedPlaceholdersAllowed`.
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 0
+      #
+      #   # bad
+      #   format('%06d', 10)
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%<number>06d', number: 10)
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 1 (default)
+      #
+      #   # bad
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%06d', 10)
+      #
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: ['redirect']
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example Mode: conservative, EnforcedStyle: annotated
+      #   # In `conservative` mode, offenses are only registered for strings
+      #   # given to a known formatting method.
+      #
+      #   # good
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
+      class FormatStringToken < Base
+        include ConfigurableEnforcedStyle
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
+
+        def on_str(node)
+          return if format_string_token?(node) || use_allowed_method?(node)
+
+          detections = collect_detections(node)
+          return if detections.empty?
+          return if allowed_unannotated?(detections)
+
+          detections.each do |detected_sequence, token_range|
+            check_sequence(detected_sequence, token_range)
+          end
+        end
+
+        private
+
+        # @!method format_string_in_typical_context?(node)
+        def_node_matcher :format_string_in_typical_context?, <<~PATTERN
+          {
+            ^(send _ {:format :sprintf :printf} %0 ...)
+            ^(send %0 :% _)
+          }
+        PATTERN
+
+        def format_string_token?(node)
+          !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
+        end
+
+        def use_allowed_method?(node)
+          send_parent = node.each_ancestor(:send).first
+          send_parent &&
+            (allowed_method?(send_parent.method_name) ||
+            matches_allowed_pattern?(send_parent.method_name))
+        end
+
+        def check_sequence(detected_sequence, token_range)
+          if detected_sequence.style == style
+            correct_style_detected
+          elsif correctable_sequence?(detected_sequence.type)
+            style_detected(detected_sequence.style)
+            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+              autocorrect_sequence(corrector, detected_sequence, token_range)
+            end
+          end
+        end
+
+        def correctable_sequence?(detected_type)
+          detected_type == 's' || style == :annotated || style == :unannotated
+        end
+
+        def autocorrect_sequence(corrector, detected_sequence, token_range)
+          return if style == :unannotated
+
+          name = detected_sequence.name
+          return if name.nil?
+
+          flags = detected_sequence.flags
+          width = detected_sequence.width
+          precision = detected_sequence.precision
+          type = detected_sequence.style == :template ? 's' : detected_sequence.type
+          correction = case style
+                       when :annotated then "%<#{name}>#{flags}#{width}#{precision}#{type}"
+                       when :template then "%#{flags}#{width}#{precision}{#{name}}"
+                       end
+          corrector.replace(token_range, correction)
+        end
+
+        def allowed_string?(node, detected_style)
+          (detected_style == :unannotated || conservative?) &&
+            !format_string_in_typical_context?(node)
+        end
+
+        def message(detected_style)
+          "Prefer #{message_text(style)} over #{message_text(detected_style)}."
+        end
+
+        # rubocop:disable Style/FormatStringToken
+        def message_text(style)
+          {
+            annotated: 'annotated tokens (like `%<foo>s`)',
+            template: 'template tokens (like `%{foo}`)',
+            unannotated: 'unannotated tokens (like `%s`)'
+          }[style]
+        end
+        # rubocop:enable Style/FormatStringToken
+
+        def tokens(str_node, &block)
+          return if str_node.source == '__FILE__'
+
+          token_ranges(str_contents(str_node.loc), &block)
+        end
+
+        def str_contents(source_map)
+          if source_map.is_a?(Parser::Source::Map::Heredoc)
+            source_map.heredoc_body
+          elsif source_map.begin
+            source_map.expression.adjust(begin_pos: +1, end_pos: -1)
+          else
+            source_map.expression
+          end
+        end
+
+        def token_ranges(contents)
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
+
+          format_string.format_sequences.each do |detected_sequence|
+            next if detected_sequence.percent?
+
+            token = contents.begin.adjust(begin_pos: detected_sequence.begin_pos,
+                                          end_pos: detected_sequence.end_pos)
+
+            yield(detected_sequence, token)
+          end
+        end
+
+        def collect_detections(node)
+          detections = []
+          tokens(node) do |detected_sequence, token_range|
+            unless allowed_string?(node, detected_sequence.style)
+              detections << [detected_sequence, token_range]
+            end
+          end
+          detections
+        end
+
+        def allowed_unannotated?(detections)
+          return false unless detections.all? do |detected_sequence,|
+                                detected_sequence.style == :unannotated
+                              end
+          return true if detections.size <= max_unannotated_placeholders_allowed
+
+          detections.any? { |detected_sequence,| !correctable_sequence?(detected_sequence.type) }
+        end
+
+        def max_unannotated_placeholders_allowed
+          cop_config['MaxUnannotatedPlaceholdersAllowed']
+        end
+
+        def conservative?
+          cop_config.fetch('Mode', :aggressive).to_sym == :conservative
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Helps you transition from mutable string literals
+      # to frozen string literals.
+      # It will add the `# frozen_string_literal: true` magic comment to the top
+      # of files to enable frozen string literals. Frozen string literals may be
+      # default in future Ruby. The comment will be added below a shebang and
+      # encoding comment. The frozen string literal comment is only valid in Ruby 2.3+.
+      #
+      # Note that the cop will accept files where the comment exists but is set
+      # to `false` instead of `true`.
+      #
+      # To require a blank line after this comment, please see
+      # `Layout/EmptyLineAfterMagicComment` cop.
+      #
+      # @safety
+      #  This cop's autocorrection is unsafe since any strings mutations will
+      #  change from being accepted to raising `FrozenError`, as all strings
+      #  will become frozen by default, and will need to be manually refactored.
+      #
+      # @example EnforcedStyle: always (default)
+      #   # The `always` style will always add the frozen string literal comment
+      #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
+      #   # called on a string literal.
+      #   # bad
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: false
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: never
+      #   # The `never` will enforce that the frozen string literal comment does
+      #   # not exist in a file.
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: always_true
+      #   # The `always_true` style enforces that the frozen string literal
+      #   # comment is set to `true`. This is a stricter option than `always`
+      #   # and forces projects to use frozen string literals.
+      #   # bad
+      #   # frozen_string_literal: false
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      class FrozenStringLiteralComment < Base
+        include ConfigurableEnforcedStyle
+        include FrozenStringLiteral
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
+
+        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: true`.'
+        MSG_MISSING = 'Missing frozen string literal comment.'
+        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'
+        MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
+        SHEBANG = '#!'
+
+        def on_new_investigation
+          return if processed_source.tokens.empty?
+
+          case style
+          when :never
+            ensure_no_comment(processed_source)
+          when :always_true
+            ensure_enabled_comment(processed_source)
+          else
+            ensure_comment(processed_source)
+          end
+        end
+
+        private
+
+        def ensure_no_comment(processed_source)
+          return unless frozen_string_literal_comment_exists?
+
+          unnecessary_comment_offense(processed_source)
+        end
+
+        def ensure_comment(processed_source)
+          return if frozen_string_literal_comment_exists?
+
+          missing_offense(processed_source)
+        end
+
+        def ensure_enabled_comment(processed_source)
+          if frozen_string_literal_specified?
+            return if frozen_string_literals_enabled?
+
+            # The comment exists, but is not enabled.
+            disabled_offense(processed_source)
+          else # The comment doesn't exist at all.
+            missing_true_offense(processed_source)
+          end
+        end
+
+        def last_special_comment(processed_source)
+          token_number = 0
+          if processed_source.tokens[token_number].text.start_with?(SHEBANG)
+            token = processed_source.tokens[token_number]
+            token_number += 1
+          end
+
+          next_token = processed_source.tokens[token_number]
+          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+            token = next_token
+          end
+
+          token
+        end
+
+        def frozen_string_literal_comment(processed_source)
+          processed_source.tokens.find do |token|
+            MagicComment.parse(token.text).frozen_string_literal_specified?
+          end
+        end
+
+        def missing_offense(processed_source)
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(range, message: MSG_MISSING) { |corrector| insert_comment(corrector) }
+        end
+
+        def missing_true_offense(processed_source)
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(range, message: MSG_MISSING_TRUE) { |corrector| insert_comment(corrector) }
+        end
+
+        def unnecessary_comment_offense(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment.pos, message: MSG_UNNECESSARY) do |corrector|
+            remove_comment(corrector, frozen_string_literal_comment)
+          end
+        end
+
+        def disabled_offense(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment.pos, message: MSG_DISABLED) do |corrector|
+            enable_comment(corrector)
+          end
+        end
+
+        def remove_comment(corrector, node)
+          corrector.remove(range_with_surrounding_space(node.pos, side: :right))
+        end
+
+        def enable_comment(corrector)
+          comment = frozen_string_literal_comment(processed_source)
+          replacement = MagicComment.parse(comment.text).new_frozen_string_literal(true)
+
+          corrector.replace(line_range(comment.line), replacement)
+        end
+
+        def insert_comment(corrector)
+          comment = last_special_comment(processed_source)
+
+          if comment
+            corrector.insert_after(line_range(comment.line), following_comment)
+          else
+            corrector.insert_before(processed_source.buffer.source_range, preceding_comment)
+          end
+        end
+
+        def line_range(line)
+          processed_source.buffer.line_range(line)
+        end
+
+        def preceding_comment
+          "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+        end
+
+        def following_comment
+          "\n#{FROZEN_STRING_LITERAL_ENABLED}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
+      # `STDOUT/STDERR/STDIN` are constants, and while you can actually
+      # reassign (possibly to redirect some stream) constants in Ruby, you'll get
+      # an interpreter warning if you do so.
+      #
+      # Additionally, `$stdout/$stderr/$stdin` can safely be accessed in a Ractor because they
+      # are ractor-local, while `STDOUT/STDERR/STDIN` will raise `Ractor::IsolationError`.
+      #
+      # @safety
+      #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
+      #   objects, for example.
+      #
+      # @example
+      #   # bad
+      #   STDOUT.puts('hello')
+      #
+      #   hash = { out: STDOUT, key: value }
+      #
+      #   def m(out = STDOUT)
+      #     out.puts('hello')
+      #   end
+      #
+      #   # good
+      #   $stdout.puts('hello')
+      #
+      #   hash = { out: $stdout, key: value }
+      #
+      #   def m(out = $stdout)
+      #     out.puts('hello')
+      #   end
+      #
+      class GlobalStdStream < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<gvar_name>s` instead of `%<const_name>s`.'
+
+        STD_STREAMS = %i[STDIN STDOUT STDERR].to_set.freeze
+
+        # @!method const_to_gvar_assignment?(node, name)
+        def_node_matcher :const_to_gvar_assignment?, <<~PATTERN
+          (gvasgn %1 (const nil? _))
+        PATTERN
+
+        def on_const(node)
+          return if namespaced?(node)
+
+          const_name = node.short_name
+          return unless STD_STREAMS.include?(const_name)
+
+          gvar_name = gvar_name(const_name).to_sym
+          return if const_to_gvar_assignment?(node.parent, gvar_name)
+
+          add_offense(node, message: message(const_name)) do |corrector|
+            corrector.replace(node, gvar_name)
+          end
+        end
+
+        private
+
+        def message(const_name)
+          format(MSG, gvar_name: gvar_name(const_name), const_name: const_name)
+        end
+
+        def namespaced?(node)
+          !node.namespace.nil? && (node.relative? || !node.namespace.cbase_type?)
+        end
+
+        def gvar_name(const_name)
+          "$#{const_name.to_s.downcase}"
+        end
+      end
+    end
+  end
+end