Class: Parser::Source::TreeRewriter

Inherits:
Object
  • Object
show all
Extended by:
Deprecation
Defined in:
lib/parser/source/tree_rewriter.rb

Overview

TreeRewriter performs the heavy lifting in the source rewriting process. It schedules code updates to be performed in the correct order.

For simple cases, the resulting source will be obvious.

Examples for more complex cases follow. Assume these examples are acting on the source `'puts(:hello, :world)`. The methods #wrap, #remove, etc. receive a Range as first argument; for clarity, examples below use english sentences and a string of raw code instead.

## Overlapping ranges:

Any two rewriting actions on overlapping ranges will fail and raise a `ClobberingError`, unless they are both deletions (covered next).

  • wrap ':hello, ' with '(' and ')'

  • wrap ', :world' with '(' and ')'

=> CloberringError

## Overlapping deletions:

  • remove ':hello, '

  • remove ', :world'

The overlapping ranges are merged and `':hello, :world'` will be removed. This policy can be changed. `:crossing_deletions` defaults to `:accept` but can be set to `:warn` or `:raise`.

## Multiple actions at the same end points:

Results will always be independent on the order they were given. Exception: rewriting actions done on exactly the same range (covered next).

Example:

  • replace ', ' by ' => '

  • wrap ':hello, :world' with 'and ''

  • replace ':world' with ':everybody'

  • wrap ':world' with '[', ']'

The resulting string will be `'puts(=> [:everybody])'` and this result is independent on the order the instructions were given in.

Note that if the two “replace” were given as a single replacement of ', :world' for ' => :everybody', the result would be a `ClobberingError` because of the wrap in square brackets.

## Multiple wraps on same range:

  • wrap ':hello' with '(' and ')'

  • wrap ':hello' with '[' and ']'

The wraps are combined in order given and results would be `'puts(, :world)'`.

## Multiple replacements on same range:

  • replace ':hello' by ':hi', then

  • replace ':hello' by ':hey'

The replacements are made in the order given, so the latter replacement supersedes the former and ':hello' will be replaced by ':hey'.

This policy can be changed. `:different_replacements` defaults to `:accept` but can be set to `:warn` or `:raise`.

## Swallowed insertions: wrap 'world' by '__', '__' replace ':hello, :world' with ':hi'

A containing replacement will swallow the contained rewriting actions and `':hello, :world'` will be replaced by `':hi'`.

This policy can be changed for swallowed insertions. `:swallowed_insertions` defaults to `:accept` but can be set to `:warn` or `:raise`

## Implementation The updates are organized in a tree, according to the ranges they act on (where children are strictly contained by their parent), hence the name.

Defined Under Namespace

Classes: Action

Constant Summary collapse

DEPRECATION_WARNING =
[
  'TreeRewriter#insert_before_multi and insert_before_multi exist only for legacy compatibility.',
  'Please update your code to use `wrap`, `insert_before` or `insert_after` instead.'
].join("\n").freeze

Instance Attribute Summary collapse

Attributes included from Deprecation

#warned_of_deprecation

Instance Method Summary collapse

Methods included from Deprecation

warn_of_deprecation

Constructor Details

#initialize(source_buffer, crossing_deletions: :accept, different_replacements: :accept, swallowed_insertions: :accept) ⇒ TreeRewriter

Returns a new instance of TreeRewriter.

Parameters:


98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
# File 'lib/parser/source/tree_rewriter.rb', line 98

def initialize(source_buffer,
               crossing_deletions: :accept,
               different_replacements: :accept,
               swallowed_insertions: :accept)
  @diagnostics = Diagnostic::Engine.new
  @diagnostics.consumer = -> diag { $stderr.puts diag.render }

  @source_buffer = source_buffer
  @in_transaction = false

  @policy = {crossing_deletions: crossing_deletions,
             different_replacements: different_replacements,
             swallowed_insertions: swallowed_insertions}.freeze
  check_policy_validity

  @enforcer = method(:enforce_policy)
  # We need a range that would be jugded as containing all other ranges,
  # including 0...0 and size...size:
  all_encompassing_range = @source_buffer.source_range.adjust(begin_pos: -1, end_pos: +1)
  @action_root = TreeRewriter::Action.new(all_encompassing_range, @enforcer)
end

Instance Attribute Details

#diagnosticsDiagnostic::Engine (readonly)

Returns:


91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
# File 'lib/parser/source/tree_rewriter.rb', line 91

class TreeRewriter
  attr_reader :source_buffer
  attr_reader :diagnostics

  ##
  # @param [Source::Buffer] source_buffer
  #
  def initialize(source_buffer,
                 crossing_deletions: :accept,
                 different_replacements: :accept,
                 swallowed_insertions: :accept)
    @diagnostics = Diagnostic::Engine.new
    @diagnostics.consumer = -> diag { $stderr.puts diag.render }

    @source_buffer = source_buffer
    @in_transaction = false

    @policy = {crossing_deletions: crossing_deletions,
               different_replacements: different_replacements,
               swallowed_insertions: swallowed_insertions}.freeze
    check_policy_validity

    @enforcer = method(:enforce_policy)
    # We need a range that would be jugded as containing all other ranges,
    # including 0...0 and size...size:
    all_encompassing_range = @source_buffer.source_range.adjust(begin_pos: -1, end_pos: +1)
    @action_root = TreeRewriter::Action.new(all_encompassing_range, @enforcer)
  end

  ##
  # Returns true iff no (non trivial) update has been recorded
  #
  # @return [Boolean]
  #
  def empty?
    @action_root.empty?
  end

  ##
  # Merges the updates of argument with the receiver.
  # Policies of the receiver are used.
  # This action is atomic in that it won't change the receiver
  # unless it succeeds.
  #
  # @param [Rewriter] with
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def merge!(with)
    raise 'TreeRewriter are not for the same source_buffer' unless
      source_buffer == with.source_buffer

    @action_root = @action_root.combine(with.action_root)
    self
  end

  ##
  # Returns a new rewriter that consists of the updates of the received
  # and the given argument. Policies of the receiver are used.
  #
  # @param [Rewriter] with
  # @return [Rewriter] merge of receiver and argument
  # @raise [ClobberingError] when clobbering is detected
  #
  def merge(with)
    dup.merge!(with)
  end

  ##
  # For special cases where one needs to merge a rewriter attached to a different source_buffer
  # or that needs to be offset. Policies of the receiver are used.
  #
  # @param [TreeRewriter] rewriter from different source_buffer
  # @param [Integer] offset
  # @return [Rewriter] self
  # @raise [IndexError] if action ranges (once offset) don't fit the current buffer
  #
  def import!(foreign_rewriter, offset: 0)
    return self if foreign_rewriter.empty?

    contracted = foreign_rewriter.action_root.contract
    merge_effective_range = ::Parser::Source::Range.new(
      @source_buffer,
      contracted.range.begin_pos + offset,
      contracted.range.end_pos + offset,
    )
    check_range_validity(merge_effective_range)

    merge_with = contracted.moved(@source_buffer, offset)

    @action_root = @action_root.combine(merge_with)
    self
  end

  ##
  # Replaces the code of the source range `range` with `content`.
  #
  # @param [Range] range
  # @param [String] content
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def replace(range, content)
    combine(range, replacement: content)
  end

  ##
  # Inserts the given strings before and after the given range.
  #
  # @param [Range] range
  # @param [String, nil] insert_before
  # @param [String, nil] insert_after
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def wrap(range, insert_before, insert_after)
    combine(range, insert_before: insert_before.to_s, insert_after: insert_after.to_s)
  end

  ##
  # Shortcut for `replace(range, '')`
  #
  # @param [Range] range
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def remove(range)
    replace(range, ''.freeze)
  end


  ##
  # Shortcut for `wrap(range, content, nil)`
  #
  # @param [Range] range
  # @param [String] content
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def insert_before(range, content)
    wrap(range, content, nil)
  end

  ##
  # Shortcut for `wrap(range, nil, content)`
  #
  # @param [Range] range
  # @param [String] content
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def insert_after(range, content)
    wrap(range, nil, content)
  end

  ##
  # Applies all scheduled changes to the `source_buffer` and returns
  # modified source as a new string.
  #
  # @return [String]
  #
  def process
    source     = @source_buffer.source

    chunks = []
    last_end = 0
    @action_root.ordered_replacements.each do |range, replacement|
      chunks << source[last_end...range.begin_pos] << replacement
      last_end = range.end_pos
    end
    chunks << source[last_end...source.length]
    chunks.join
  end

  ##
  # Returns a representation of the rewriter as an ordered list of replacements.
  #
  #     rewriter.as_replacements # => [ [1...1, '('],
  #                                     [2...4, 'foo'],
  #                                     [5...6, ''],
  #                                     [6...6, '!'],
  #                                     [10...10, ')'],
  #                                   ]
  #
  # This representation is sufficient to recreate the result of `process` but it is
  # not sufficient to recreate completely the rewriter for further merging/actions.
  # See `as_nested_actions`
  #
  # @return [Array<Range, String>] an ordered list of pairs of range & replacement
  #
  def as_replacements
    @action_root.ordered_replacements
  end

  ##
  # Returns a representation of the rewriter as nested insertions (:wrap) and replacements.
  #
  #     rewriter.as_actions # =>[ [:wrap, 1...10, '(', ')'],
  #                               [:wrap, 2...6, '', '!'],  # aka "insert_after"
  #                               [:replace, 2...4, 'foo'],
  #                               [:replace, 5...6, ''],  # aka "removal"
  #                             ],
  #
  # Contrary to `as_replacements`, this representation is sufficient to recreate exactly
  # the rewriter.
  #
  # @return [Array<(Symbol, Range, String{, String})>]
  #
  def as_nested_actions
    @action_root.nested_actions
  end

  ##
  # Provides a protected block where a sequence of multiple rewrite actions
  # are handled atomically. If any of the actions failed by clobbering,
  # all the actions are rolled back. Transactions can be nested.
  #
  # @raise [RuntimeError] when no block is passed
  #
  def transaction
    unless block_given?
      raise "#{self.class}##{__method__} requires block"
    end

    previous = @in_transaction
    @in_transaction = true
    restore_root = @action_root

    yield

    restore_root = nil

    self
  ensure
    @action_root = restore_root if restore_root
    @in_transaction = previous
  end

  def in_transaction?
    @in_transaction
  end

  # :nodoc:
  def inspect
    "#<#{self.class} #{source_buffer.name}: #{action_summary}>"
  end

  ##
  # @api private
  # @deprecated Use insert_after or wrap
  #
  def insert_before_multi(range, text)
    self.class.warn_of_deprecation
    insert_before(range, text)
  end

  ##
  # @api private
  # @deprecated Use insert_after or wrap
  #
  def insert_after_multi(range, text)
    self.class.warn_of_deprecation
    insert_after(range, text)
  end

  DEPRECATION_WARNING = [
    'TreeRewriter#insert_before_multi and insert_before_multi exist only for legacy compatibility.',
    'Please update your code to use `wrap`, `insert_before` or `insert_after` instead.'
  ].join("\n").freeze

  extend Deprecation

  protected

  attr_reader :action_root

  private

  def action_summary
    replacements = as_replacements
    case replacements.size
    when 0 then return 'empty'
    when 1..3 then #ok
    else
      replacements = replacements.first(3)
      suffix = ''
    end
    parts = replacements.map do |(range, str)|
      if str.empty? # is this a deletion?
        "-#{range.to_range}"
      elsif range.size == 0 # is this an insertion?
        "+#{str.inspect}@#{range.begin_pos}"
      else # it is a replacement
        "^#{str.inspect}@#{range.to_range}"
      end
    end
    parts << suffix if suffix
    parts.join(', ')
  end

  ACTIONS = %i[accept warn raise].freeze
  def check_policy_validity
    invalid = @policy.values - ACTIONS
    raise ArgumentError, "Invalid policy: #{invalid.join(', ')}" unless invalid.empty?
  end

  def combine(range, attributes)
    range = check_range_validity(range)
    action = TreeRewriter::Action.new(range, @enforcer, **attributes)
    @action_root = @action_root.combine(action)
    self
  end

  def check_range_validity(range)
    if range.begin_pos < 0 || range.end_pos > @source_buffer.source.size
      raise IndexError, "The range #{range.to_range} is outside the bounds of the source"
    end
    range
  end

  def enforce_policy(event)
    return if @policy[event] == :accept
    return unless (values = yield)
    trigger_policy(event, **values)
  end

  POLICY_TO_LEVEL = {warn: :warning, raise: :error}.freeze
  def trigger_policy(event, range: raise, conflict: nil, **arguments)
    action = @policy[event] || :raise
    diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], event, arguments, range)
    @diagnostics.process(diag)
    if conflict
      range, *highlights = conflict
      diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], :"#{event}_conflict", arguments, range, highlights)
      @diagnostics.process(diag)
    end
    raise Parser::ClobberingError, "Parser::Source::TreeRewriter detected clobbering" if action == :raise
  end
end

#source_bufferSource::Buffer (readonly)

Returns:


91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
# File 'lib/parser/source/tree_rewriter.rb', line 91

class TreeRewriter
  attr_reader :source_buffer
  attr_reader :diagnostics

  ##
  # @param [Source::Buffer] source_buffer
  #
  def initialize(source_buffer,
                 crossing_deletions: :accept,
                 different_replacements: :accept,
                 swallowed_insertions: :accept)
    @diagnostics = Diagnostic::Engine.new
    @diagnostics.consumer = -> diag { $stderr.puts diag.render }

    @source_buffer = source_buffer
    @in_transaction = false

    @policy = {crossing_deletions: crossing_deletions,
               different_replacements: different_replacements,
               swallowed_insertions: swallowed_insertions}.freeze
    check_policy_validity

    @enforcer = method(:enforce_policy)
    # We need a range that would be jugded as containing all other ranges,
    # including 0...0 and size...size:
    all_encompassing_range = @source_buffer.source_range.adjust(begin_pos: -1, end_pos: +1)
    @action_root = TreeRewriter::Action.new(all_encompassing_range, @enforcer)
  end

  ##
  # Returns true iff no (non trivial) update has been recorded
  #
  # @return [Boolean]
  #
  def empty?
    @action_root.empty?
  end

  ##
  # Merges the updates of argument with the receiver.
  # Policies of the receiver are used.
  # This action is atomic in that it won't change the receiver
  # unless it succeeds.
  #
  # @param [Rewriter] with
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def merge!(with)
    raise 'TreeRewriter are not for the same source_buffer' unless
      source_buffer == with.source_buffer

    @action_root = @action_root.combine(with.action_root)
    self
  end

  ##
  # Returns a new rewriter that consists of the updates of the received
  # and the given argument. Policies of the receiver are used.
  #
  # @param [Rewriter] with
  # @return [Rewriter] merge of receiver and argument
  # @raise [ClobberingError] when clobbering is detected
  #
  def merge(with)
    dup.merge!(with)
  end

  ##
  # For special cases where one needs to merge a rewriter attached to a different source_buffer
  # or that needs to be offset. Policies of the receiver are used.
  #
  # @param [TreeRewriter] rewriter from different source_buffer
  # @param [Integer] offset
  # @return [Rewriter] self
  # @raise [IndexError] if action ranges (once offset) don't fit the current buffer
  #
  def import!(foreign_rewriter, offset: 0)
    return self if foreign_rewriter.empty?

    contracted = foreign_rewriter.action_root.contract
    merge_effective_range = ::Parser::Source::Range.new(
      @source_buffer,
      contracted.range.begin_pos + offset,
      contracted.range.end_pos + offset,
    )
    check_range_validity(merge_effective_range)

    merge_with = contracted.moved(@source_buffer, offset)

    @action_root = @action_root.combine(merge_with)
    self
  end

  ##
  # Replaces the code of the source range `range` with `content`.
  #
  # @param [Range] range
  # @param [String] content
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def replace(range, content)
    combine(range, replacement: content)
  end

  ##
  # Inserts the given strings before and after the given range.
  #
  # @param [Range] range
  # @param [String, nil] insert_before
  # @param [String, nil] insert_after
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def wrap(range, insert_before, insert_after)
    combine(range, insert_before: insert_before.to_s, insert_after: insert_after.to_s)
  end

  ##
  # Shortcut for `replace(range, '')`
  #
  # @param [Range] range
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def remove(range)
    replace(range, ''.freeze)
  end


  ##
  # Shortcut for `wrap(range, content, nil)`
  #
  # @param [Range] range
  # @param [String] content
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def insert_before(range, content)
    wrap(range, content, nil)
  end

  ##
  # Shortcut for `wrap(range, nil, content)`
  #
  # @param [Range] range
  # @param [String] content
  # @return [Rewriter] self
  # @raise [ClobberingError] when clobbering is detected
  #
  def insert_after(range, content)
    wrap(range, nil, content)
  end

  ##
  # Applies all scheduled changes to the `source_buffer` and returns
  # modified source as a new string.
  #
  # @return [String]
  #
  def process
    source     = @source_buffer.source

    chunks = []
    last_end = 0
    @action_root.ordered_replacements.each do |range, replacement|
      chunks << source[last_end...range.begin_pos] << replacement
      last_end = range.end_pos
    end
    chunks << source[last_end...source.length]
    chunks.join
  end

  ##
  # Returns a representation of the rewriter as an ordered list of replacements.
  #
  #     rewriter.as_replacements # => [ [1...1, '('],
  #                                     [2...4, 'foo'],
  #                                     [5...6, ''],
  #                                     [6...6, '!'],
  #                                     [10...10, ')'],
  #                                   ]
  #
  # This representation is sufficient to recreate the result of `process` but it is
  # not sufficient to recreate completely the rewriter for further merging/actions.
  # See `as_nested_actions`
  #
  # @return [Array<Range, String>] an ordered list of pairs of range & replacement
  #
  def as_replacements
    @action_root.ordered_replacements
  end

  ##
  # Returns a representation of the rewriter as nested insertions (:wrap) and replacements.
  #
  #     rewriter.as_actions # =>[ [:wrap, 1...10, '(', ')'],
  #                               [:wrap, 2...6, '', '!'],  # aka "insert_after"
  #                               [:replace, 2...4, 'foo'],
  #                               [:replace, 5...6, ''],  # aka "removal"
  #                             ],
  #
  # Contrary to `as_replacements`, this representation is sufficient to recreate exactly
  # the rewriter.
  #
  # @return [Array<(Symbol, Range, String{, String})>]
  #
  def as_nested_actions
    @action_root.nested_actions
  end

  ##
  # Provides a protected block where a sequence of multiple rewrite actions
  # are handled atomically. If any of the actions failed by clobbering,
  # all the actions are rolled back. Transactions can be nested.
  #
  # @raise [RuntimeError] when no block is passed
  #
  def transaction
    unless block_given?
      raise "#{self.class}##{__method__} requires block"
    end

    previous = @in_transaction
    @in_transaction = true
    restore_root = @action_root

    yield

    restore_root = nil

    self
  ensure
    @action_root = restore_root if restore_root
    @in_transaction = previous
  end

  def in_transaction?
    @in_transaction
  end

  # :nodoc:
  def inspect
    "#<#{self.class} #{source_buffer.name}: #{action_summary}>"
  end

  ##
  # @api private
  # @deprecated Use insert_after or wrap
  #
  def insert_before_multi(range, text)
    self.class.warn_of_deprecation
    insert_before(range, text)
  end

  ##
  # @api private
  # @deprecated Use insert_after or wrap
  #
  def insert_after_multi(range, text)
    self.class.warn_of_deprecation
    insert_after(range, text)
  end

  DEPRECATION_WARNING = [
    'TreeRewriter#insert_before_multi and insert_before_multi exist only for legacy compatibility.',
    'Please update your code to use `wrap`, `insert_before` or `insert_after` instead.'
  ].join("\n").freeze

  extend Deprecation

  protected

  attr_reader :action_root

  private

  def action_summary
    replacements = as_replacements
    case replacements.size
    when 0 then return 'empty'
    when 1..3 then #ok
    else
      replacements = replacements.first(3)
      suffix = ''
    end
    parts = replacements.map do |(range, str)|
      if str.empty? # is this a deletion?
        "-#{range.to_range}"
      elsif range.size == 0 # is this an insertion?
        "+#{str.inspect}@#{range.begin_pos}"
      else # it is a replacement
        "^#{str.inspect}@#{range.to_range}"
      end
    end
    parts << suffix if suffix
    parts.join(', ')
  end

  ACTIONS = %i[accept warn raise].freeze
  def check_policy_validity
    invalid = @policy.values - ACTIONS
    raise ArgumentError, "Invalid policy: #{invalid.join(', ')}" unless invalid.empty?
  end

  def combine(range, attributes)
    range = check_range_validity(range)
    action = TreeRewriter::Action.new(range, @enforcer, **attributes)
    @action_root = @action_root.combine(action)
    self
  end

  def check_range_validity(range)
    if range.begin_pos < 0 || range.end_pos > @source_buffer.source.size
      raise IndexError, "The range #{range.to_range} is outside the bounds of the source"
    end
    range
  end

  def enforce_policy(event)
    return if @policy[event] == :accept
    return unless (values = yield)
    trigger_policy(event, **values)
  end

  POLICY_TO_LEVEL = {warn: :warning, raise: :error}.freeze
  def trigger_policy(event, range: raise, conflict: nil, **arguments)
    action = @policy[event] || :raise
    diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], event, arguments, range)
    @diagnostics.process(diag)
    if conflict
      range, *highlights = conflict
      diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], :"#{event}_conflict", arguments, range, highlights)
      @diagnostics.process(diag)
    end
    raise Parser::ClobberingError, "Parser::Source::TreeRewriter detected clobbering" if action == :raise
  end
end

Instance Method Details

#as_nested_actionsArray<(Symbol, Range, String{, String})>

Returns a representation of the rewriter as nested insertions (:wrap) and replacements.

rewriter.as_actions # =>[ [:wrap, 1...10, '(', ')'],
                          [:wrap, 2...6, '', '!'],  # aka "insert_after"
                          [:replace, 2...4, 'foo'],
                          [:replace, 5...6, ''],  # aka "removal"
                        ],

Contrary to `as_replacements`, this representation is sufficient to recreate exactly the rewriter.

Returns:

  • (Array<(Symbol, Range, String{, String})>)

299
300
301
# File 'lib/parser/source/tree_rewriter.rb', line 299

def as_nested_actions
  @action_root.nested_actions
end

#as_replacementsArray<Range, String>

Returns a representation of the rewriter as an ordered list of replacements.

rewriter.as_replacements # => [ [1...1, '('],
                                [2...4, 'foo'],
                                [5...6, ''],
                                [6...6, '!'],
                                [10...10, ')'],
                              ]

This representation is sufficient to recreate the result of `process` but it is not sufficient to recreate completely the rewriter for further merging/actions. See `as_nested_actions`

Returns:

  • (Array<Range, String>)

    an ordered list of pairs of range & replacement


281
282
283
# File 'lib/parser/source/tree_rewriter.rb', line 281

def as_replacements
  @action_root.ordered_replacements
end

#empty?Boolean

Returns true iff no (non trivial) update has been recorded

Returns:

  • (Boolean)

125
126
127
# File 'lib/parser/source/tree_rewriter.rb', line 125

def empty?
  @action_root.empty?
end

#import!(foreign_rewriter, offset: 0) ⇒ Rewriter

For special cases where one needs to merge a rewriter attached to a different source_buffer or that needs to be offset. Policies of the receiver are used.

Parameters:

  • rewriter (TreeRewriter)

    from different source_buffer

  • offset (Integer) (defaults to: 0)

Returns:

Raises:

  • (IndexError)

    if action ranges (once offset) don't fit the current buffer


168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
# File 'lib/parser/source/tree_rewriter.rb', line 168

def import!(foreign_rewriter, offset: 0)
  return self if foreign_rewriter.empty?

  contracted = foreign_rewriter.action_root.contract
  merge_effective_range = ::Parser::Source::Range.new(
    @source_buffer,
    contracted.range.begin_pos + offset,
    contracted.range.end_pos + offset,
  )
  check_range_validity(merge_effective_range)

  merge_with = contracted.moved(@source_buffer, offset)

  @action_root = @action_root.combine(merge_with)
  self
end

#in_transaction?Boolean

Returns:

  • (Boolean)

329
330
331
# File 'lib/parser/source/tree_rewriter.rb', line 329

def in_transaction?
  @in_transaction
end

#insert_after(range, content) ⇒ Rewriter

Shortcut for `wrap(range, nil, content)`

Parameters:

  • range (Range)
  • content (String)

Returns:

Raises:


242
243
244
# File 'lib/parser/source/tree_rewriter.rb', line 242

def insert_after(range, content)
  wrap(range, nil, content)
end

#insert_after_multi(range, text) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated.

Use insert_after or wrap


351
352
353
354
# File 'lib/parser/source/tree_rewriter.rb', line 351

def insert_after_multi(range, text)
  self.class.warn_of_deprecation
  insert_after(range, text)
end

#insert_before(range, content) ⇒ Rewriter

Shortcut for `wrap(range, content, nil)`

Parameters:

  • range (Range)
  • content (String)

Returns:

Raises:


230
231
232
# File 'lib/parser/source/tree_rewriter.rb', line 230

def insert_before(range, content)
  wrap(range, content, nil)
end

#insert_before_multi(range, text) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated.

Use insert_after or wrap


342
343
344
345
# File 'lib/parser/source/tree_rewriter.rb', line 342

def insert_before_multi(range, text)
  self.class.warn_of_deprecation
  insert_before(range, text)
end

#inspectObject

:nodoc:


334
335
336
# File 'lib/parser/source/tree_rewriter.rb', line 334

def inspect
  "#<#{self.class} #{source_buffer.name}: #{action_summary}>"
end

#merge(with) ⇒ Rewriter

Returns a new rewriter that consists of the updates of the received and the given argument. Policies of the receiver are used.

Parameters:

Returns:

  • (Rewriter)

    merge of receiver and argument

Raises:


155
156
157
# File 'lib/parser/source/tree_rewriter.rb', line 155

def merge(with)
  dup.merge!(with)
end

#merge!(with) ⇒ Rewriter

Merges the updates of argument with the receiver. Policies of the receiver are used. This action is atomic in that it won't change the receiver unless it succeeds.

Parameters:

Returns:

Raises:


139
140
141
142
143
144
145
# File 'lib/parser/source/tree_rewriter.rb', line 139

def merge!(with)
  raise 'TreeRewriter are not for the same source_buffer' unless
    source_buffer == with.source_buffer

  @action_root = @action_root.combine(with.action_root)
  self
end

#processString

Applies all scheduled changes to the `source_buffer` and returns modified source as a new string.

Returns:

  • (String)

252
253
254
255
256
257
258
259
260
261
262
263
# File 'lib/parser/source/tree_rewriter.rb', line 252

def process
  source     = @source_buffer.source

  chunks = []
  last_end = 0
  @action_root.ordered_replacements.each do |range, replacement|
    chunks << source[last_end...range.begin_pos] << replacement
    last_end = range.end_pos
  end
  chunks << source[last_end...source.length]
  chunks.join
end

#remove(range) ⇒ Rewriter

Shortcut for `replace(range, '')`

Parameters:

Returns:

Raises:


217
218
219
# File 'lib/parser/source/tree_rewriter.rb', line 217

def remove(range)
  replace(range, ''.freeze)
end

#replace(range, content) ⇒ Rewriter

Replaces the code of the source range `range` with `content`.

Parameters:

  • range (Range)
  • content (String)

Returns:

Raises:


193
194
195
# File 'lib/parser/source/tree_rewriter.rb', line 193

def replace(range, content)
  combine(range, replacement: content)
end

#transactionObject

Provides a protected block where a sequence of multiple rewrite actions are handled atomically. If any of the actions failed by clobbering, all the actions are rolled back. Transactions can be nested.

Raises:

  • (RuntimeError)

    when no block is passed


310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
# File 'lib/parser/source/tree_rewriter.rb', line 310

def transaction
  unless block_given?
    raise "#{self.class}##{__method__} requires block"
  end

  previous = @in_transaction
  @in_transaction = true
  restore_root = @action_root

  yield

  restore_root = nil

  self
ensure
  @action_root = restore_root if restore_root
  @in_transaction = previous
end

#wrap(range, insert_before, insert_after) ⇒ Rewriter

Inserts the given strings before and after the given range.

Parameters:

  • range (Range)
  • insert_before (String, nil)
  • insert_after (String, nil)

Returns:

Raises:


206
207
208
# File 'lib/parser/source/tree_rewriter.rb', line 206

def wrap(range, insert_before, insert_after)
  combine(range, insert_before: insert_before.to_s, insert_after: insert_after.to_s)
end