Class: Shirobai::Cop::Style::PercentLiteralDelimiters

Inherits:
RuboCop::Cop::Base
  • Object
show all
Extended by:
RuboCop::Cop::AutoCorrector
Defined in:
lib/shirobai/cop/style/percent_literal_delimiters.rb

Overview

Drop-in Rust reimplementation of ‘Style/PercentLiteralDelimiters`.

Rust walks every percent literal once and decides on a per-type ‘PreferredDelimiters` lookup (resolved Ruby-side from `default` + per-type overrides) whether the literal:

  • already uses the preferred opener, OR

  • contains the preferred opener/closer in any str/sym child source (stock’s ‘contains_preferred_delimiter?`), OR

  • (for ‘%w` / `%i` only) contains the begin delimiter’s matchpair character — ‘(`/`)` / `[`/`]` / ``/`` / `<`/`>` or the mirror single-byte forms — in a child source (stock’s ‘include_same_character_as_used_for_delimiter?`).

When none of the skips apply, Rust returns the offense range plus the ‘opening_loc` and the single-byte closer (so regex options like the trailing `i` in `%r(.*)i` survive the autocorrect, matching stock’s ‘node.loc.end` byte width). The wrapper builds the offense + corrector, formatting both with the resolved preferred pair for the literal’s type.

Constant Summary collapse

MSG = 
"`%<type>s`-literals should be delimited by `%<open>s` and `%<close>s`."
TYPES =

Canonical type order shared with ‘crates/…/percent_literal_delimiters.rs` and stock’s ‘PreferredDelimiters::PERCENT_LITERAL_TYPES`.

["%", "%i", "%I", "%q", "%Q", "%r", "%s", "%w", "%W", "%x"].freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.badge ⇒ Object 



35
 
# File 'lib/shirobai/cop/style/percent_literal_delimiters.rb', line 35

def self.badge = RuboCop::Cop::Badge.parse("Style/PercentLiteralDelimiters")

.bundle_args(config) ⇒ Object

Returns ‘[pairs]` — a 10-entry list of two-byte strings packed for the bundle path’s ‘lists` slot. We resolve `default` + per-type overrides exactly like stock’s ‘PreferredDelimiters#preferred_delimiters`: when `default` is set, every type defaults to it (then overridden by its own key); without `default` the listed types still resolve.



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/shirobai/cop/style/percent_literal_delimiters.rb', line 42

def self.bundle_args(config)
  cfg = config.for_badge(badge)
  configured = cfg.fetch("PreferredDelimiters", {})
  # Stock raises ArgumentError on an unknown key. We mirror that here
  # so the `from_packed` side never sees a missing-type fallback. The
  # raise propagates through `Dispatch.bundle_token`, which surfaces
  # it just like stock would.
  invalid = configured.keys - (TYPES + ["default"])
  unless invalid.empty?
    raise ArgumentError, "Invalid preferred delimiter config key: #{invalid.join(', ')}"
  end

  default = configured["default"]
  pairs = TYPES.map do |type|
    configured[type] || default
  end
  if pairs.any?(&:nil?)
    # Missing without `default` => the type has no preferred pair; we
    # use `()` as an inert placeholder. The cop never reaches the
    # `process` arm for this type (stock would also bail out), but
    # `from_packed` insists on 10 entries.
    pairs = pairs.map { |p| p || "()" }
  end
  [pairs]
end

.cop_name ⇒ Object 



34
 
# File 'lib/shirobai/cop/style/percent_literal_delimiters.rb', line 34

def self.cop_name = "Style/PercentLiteralDelimiters"

Instance Method Details

#bundle_eligible? ⇒ Boolean

Returns:

  • (Boolean) 


68
69
70
 
# File 'lib/shirobai/cop/style/percent_literal_delimiters.rb', line 68

def bundle_eligible?
  true
end

#on_new_investigation ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/shirobai/cop/style/percent_literal_delimiters.rb', line 72

def on_new_investigation
  buffer = processed_source.buffer
  off = SourceOffsets.for(processed_source.raw_source)

  resolved_result.each do |start_offset, end_offset, begin_start, begin_end,
                           end_start, end_end, type_index|
    type = TYPES[type_index]
    open_delim, close_delim = preferred_pair_for(type).chars

    range = Parser::Source::Range.new(buffer, off[start_offset], off[end_offset])
    message = format(MSG, type: type, open: open_delim, close: close_delim)
    add_offense(range, message: message) do |corrector|
      begin_range = Parser::Source::Range.new(
        buffer, off[begin_start], off[begin_end]
      )
      end_range = Parser::Source::Range.new(
        buffer, off[end_start], off[end_end]
      )
      corrector.replace(begin_range, "#{type}#{open_delim}")
      corrector.replace(end_range, close_delim)
    end
  end
end