Class: Shirobai::Cop::Style::BlockDelimiters

Inherits:
RuboCop::Cop::Base
  • Object
show all
Extended by:
RuboCop::Cop::AutoCorrector
Includes:
RuboCop::Cop::AllowedMethods, RuboCop::Cop::AllowedPattern
Defined in:
lib/shirobai/cop/style/block_delimiters.rb

Overview

Drop-in Rust reimplementation of Style/BlockDelimiters.

Rust walks the AST once, replicating stock's callback order: on_send registers every block inside unparenthesized call arguments as ignored, and on_block (calls, super, lambda literals, numbered/it blocks) judges the configured style (all four EnforcedStyles, the require_do_end? rescue quirk, BracesRequiredMethods, AllowedMethods, and the parser-parent emulation behind semantic). Corrections come back as the exact corrector call sequence (replace/remove/insert_before/insert_after/wrap), including the comment relocation and the begin..end wrapping of rescue bodies.

The cop instance accumulates the ignored block ranges across autocorrect iterations, mirroring IgnoredNode's @ignored_nodes (which is never reset between investigations on one instance): blocks ignored by on_send unconditionally, offense blocks only when the offense is enabled — which is why the ignore lands inside the add_offense block, exactly like stock's ignore_node.

The bundled / resolved path assumes every offense is enabled. When Rust reports that a candidate was suppressed solely by another offense's range (has_conditional — its real fate depends on rubocop:disable directives), or when AllowedPatterns need regex matching, the wrapper replays the raw event stream through add_offense, which natively reproduces the disable semantics.

Constant Summary collapse

STYLES = 
{
  "line_count_based" => 0,
  "semantic" => 1,
  "braces_for_chaining" => 2,
  "always_braces" => 3
}.freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.autocorrect_incompatible_with ⇒ Object

Style/RedundantBegin rewrites the same begin bodies the do-end-to-braces correction wraps.



42
43
44
 
# File 'lib/shirobai/cop/style/block_delimiters.rb', line 42

def self.autocorrect_incompatible_with
  [RuboCop::Cop::Style::RedundantBegin]
end

.badge ⇒ Object 



38
 
# File 'lib/shirobai/cop/style/block_delimiters.rb', line 38

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

.bundle_args(config) ⇒ Object

Packed args for the bundled run: [nums, lists] with nums = [style, AllowBracesOnProceduralOneLiners] and lists = [ProceduralMethods, FunctionalMethods, AllowedMethods, BracesRequiredMethods].



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/shirobai/cop/style/block_delimiters.rb', line 57

def self.bundle_args(config)
  cop_config = config.for_badge(badge)
  [
    [
      STYLES.fetch(cop_config["EnforcedStyle"] || "line_count_based"),
      cop_config["AllowBracesOnProceduralOneLiners"] ? 1 : 0
    ],
    [
      Array(cop_config["ProceduralMethods"]).map(&:to_s),
      Array(cop_config["FunctionalMethods"]).map(&:to_s),
      Shirobai::Cop.allowed_methods_config(cop_config).map(&:to_s),
      Array(cop_config.fetch("BracesRequiredMethods", [])).map(&:to_s)
    ]
  ]
end

.cop_name ⇒ Object 



37
 
# File 'lib/shirobai/cop/style/block_delimiters.rb', line 37

def self.cop_name = "Style/BlockDelimiters"

Instance Method Details

#on_new_investigation ⇒ Object 



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/block_delimiters.rb', line 73

def on_new_investigation
  @ignored_ranges ||= []
  return replay_events if !allowed_patterns.empty?

  offenses, send_ignores, has_conditional = resolved_result
  # A candidate was suppressed solely by another offense's range: its
  # real fate depends on disable directives, so replay exactly.
  return replay_events if has_conditional

  buffer = processed_source.buffer
  off = SourceOffsets.for(processed_source.raw_source)
  send_ignores.each { |s, e| @ignored_ranges << [s, e] }
  offenses.each do |ts, te, bs, be, message, ops|
    range = Parser::Source::Range.new(buffer, off[ts], off[te])
    add_offense(range, message: message) do |corrector|
      apply_ops(corrector, buffer, off, ops)
      # `ignore_node` runs only when the offense is enabled; the
      # ranges stay BYTE offsets (they go back to Rust).
      @ignored_ranges << [bs, be]
    end
  end
end