Class: RDoc::Parser::PrismRuby

Inherits:
RDoc::Parser show all
Defined in:
lib/rdoc/parser/prism_ruby.rb

Overview

Parse and collect document from Ruby source code. RDoc::Parser::PrismRuby is compatible with RDoc::Parser::Ruby and aims to replace it.

Defined Under Namespace

Classes: RDocVisitor

Instance Attribute Summary collapse

Attributes inherited from RDoc::Parser

#file_name

Instance Method Summary collapse

Methods inherited from RDoc::Parser

alias_extension, binary?, can_parse, can_parse_by_name, check_modeline, for, #handle_tab_width, parse_files_matching, remove_modeline, use_markup, zip?

Constructor Details

#initialize(top_level, content, options, stats) ⇒ PrismRuby

Returns a new instance of PrismRuby.



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 21

def initialize(top_level, content, options, stats)
  super

  content = handle_tab_width(content)

  @size = 0
  @token_listeners = nil
  content = RDoc::Encoding.remove_magic_comment content
  @content = content
  @markup = @options.markup
  @track_visibility = :nodoc != @options.visibility
  @encoding = @options.encoding

  @module_nesting = [[top_level, false]]
  @container = top_level
  @visibility = :public
  @singleton = false
  @in_proc_block = false
end

Instance Attribute Details

#container ⇒ Object (readonly)

Returns the value of attribute container.



19
20
21
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 19

def container
  @container
end

#singleton ⇒ Object (readonly)

Returns the value of attribute singleton.



19
20
21
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 19

def singleton
  @singleton
end

#visibility ⇒ Object

Returns the value of attribute visibility.



18
19
20
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 18

def visibility
  @visibility
end

Instance Method Details

#add_alias_method(old_name, new_name, line_no) ⇒ Object

Handles ‘alias foo bar` and `alias_method :foo, :bar`



448
449
450
451
452
453
454
455
456
457
458
459
460
461
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 448

def add_alias_method(old_name, new_name, line_no)
  comment = consecutive_comment(line_no)
  handle_consecutive_comment_directive(@container, comment)
  visibility = @container.find_method(old_name, @singleton)&.visibility || :public
  a = RDoc::Alias.new(nil, old_name, new_name, comment, singleton: @singleton)
  handle_modifier_directive(a, line_no)
  a.store = @store
  a.line = line_no
  record_location(a)
  if should_document?(a)
    @container.add_alias(a)
    @container.find_method(new_name, @singleton)&.visibility = visibility
  end
end

#add_attributes(names, rw, line_no) ⇒ Object

Handles ‘attr :a, :b`, `attr_reader :a, :b`, `attr_writer :a, :b` and `attr_accessor :a, :b`



465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 465

def add_attributes(names, rw, line_no)
  comment = consecutive_comment(line_no)
  handle_consecutive_comment_directive(@container, comment)
  return unless @container.document_children

  names.each do |symbol|
    a = RDoc::Attr.new(nil, symbol.to_s, rw, comment, singleton: @singleton)
    a.store = @store
    a.line = line_no
    record_location(a)
    handle_modifier_directive(a, line_no)
    @container.add_attribute(a) if should_document?(a)
    a.visibility = visibility # should set after adding to container
  end
end

#add_constant(constant_name, rhs_name, start_line, end_line) ⇒ Object

Adds a constant



635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 635

def add_constant(constant_name, rhs_name, start_line, end_line)
  comment = consecutive_comment(start_line)
  handle_consecutive_comment_directive(@container, comment)
  owner, name = find_or_create_constant_owner_name(constant_name)
  return unless owner

  constant = RDoc::Constant.new(name, rhs_name, comment)
  constant.store = @store
  constant.line = start_line
  record_location(constant)
  handle_modifier_directive(constant, start_line)
  handle_modifier_directive(constant, end_line)
  owner.add_constant(constant)
  mod =
    if rhs_name =~ /^::/
      @store.find_class_or_module(rhs_name)
    else
      @container.find_module_named(rhs_name)
    end
  if mod && constant.document_self
    a = @container.add_module_alias(mod, rhs_name, constant, @top_level)
    a.store = @store
    a.line = start_line
    record_location(a)
  end
end

#add_extends(names, line_no) ⇒ Object

Handle ‘extend Foo, Bar`



502
503
504
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 502

def add_extends(names, line_no) # :nodoc:
  add_includes_extends(names, RDoc::Extend, line_no)
end

#add_includes(names, line_no) ⇒ Object

Handle ‘include Foo, Bar`



496
497
498
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 496

def add_includes(names, line_no) # :nodoc:
  add_includes_extends(names, RDoc::Include, line_no)
end

#add_includes_extends(names, rdoc_class, line_no) ⇒ Object

:nodoc:



481
482
483
484
485
486
487
488
489
490
491
492
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 481

def add_includes_extends(names, rdoc_class, line_no) # :nodoc:
  return if @in_proc_block
  comment = consecutive_comment(line_no)
  handle_consecutive_comment_directive(@container, comment)
  names.each do |name|
    ie = @container.add(rdoc_class, name, '')
    ie.store = @store
    ie.line = line_no
    ie.comment = comment
    record_location(ie)
  end
end

#add_method(name, receiver_name:, receiver_fallback_type:, visibility:, singleton:, params:, calls_super:, block_params:, tokens:, start_line:, args_end_line:, end_line:) ⇒ Object

Adds a method defined by ‘def` syntax



508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 508

def add_method(name, receiver_name:, receiver_fallback_type:, visibility:, singleton:, params:, calls_super:, block_params:, tokens:, start_line:, args_end_line:, end_line:)
  return if @in_proc_block

  receiver = receiver_name ? find_or_create_module_path(receiver_name, receiver_fallback_type) : @container
  meth = RDoc::AnyMethod.new(nil, name, singleton: singleton)
  if (comment = consecutive_comment(start_line))
    handle_consecutive_comment_directive(@container, comment)
    handle_consecutive_comment_directive(meth, comment)

    comment.normalize
    meth.call_seq = comment.extract_call_seq
    meth.comment = comment
  end
  handle_modifier_directive(meth, start_line)
  handle_modifier_directive(meth, args_end_line)
  handle_modifier_directive(meth, end_line)
  return unless should_document?(meth)

  internal_add_method(
    receiver,
    meth,
    line_no: start_line,
    visibility: visibility,
    params: params,
    calls_super: calls_super,
    block_params: block_params,
    tokens: tokens
  )

  # Rename after add_method to register duplicated 'new' and 'initialize'
  # defined in c and ruby just like the old parser did.
  if meth.name == 'initialize' && !singleton
    if meth.dont_rename_initialize
      meth.visibility = :protected
    else
      meth.name = 'new'
      meth.singleton = true
      meth.visibility = :public
    end
  end
end

#add_module_or_class(module_name, start_line, end_line, is_class: false, superclass_name: nil, superclass_expr: nil) ⇒ Object

Adds module or class



664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 664

def add_module_or_class(module_name, start_line, end_line, is_class: false, superclass_name: nil, superclass_expr: nil)
  comment = consecutive_comment(start_line)
  handle_consecutive_comment_directive(@container, comment)
  return unless @container.document_children

  owner, name = find_or_create_constant_owner_name(module_name)
  return unless owner

  if is_class
    # RDoc::NormalClass resolves superclass name despite of the lack of module nesting information.
    # We need to fix it when RDoc::NormalClass resolved to a wrong constant name
    if superclass_name
      superclass_full_path = resolve_constant_path(superclass_name)
      superclass = @store.find_class_or_module(superclass_full_path) if superclass_full_path
      superclass_full_path ||= superclass_name
      superclass_full_path = superclass_full_path.sub(/^::/, '')
    end
    # add_class should be done after resolving superclass
    mod = owner.classes_hash[name] || owner.add_class(RDoc::NormalClass, name, superclass_name || superclass_expr || '::Object')
    if superclass_name
      if superclass
        mod.superclass = superclass
      elsif (mod.superclass.is_a?(String) || mod.superclass.name == 'Object') && mod.superclass != superclass_full_path
        mod.superclass = superclass_full_path
      end
    end
  else
    mod = owner.modules_hash[name] || owner.add_module(RDoc::NormalModule, name)
  end

  mod.store = @store
  mod.line = start_line
  record_location(mod)
  handle_modifier_directive(mod, start_line)
  handle_modifier_directive(mod, end_line)
  mod.add_comment(comment, @top_level) if comment
  mod
end

#call_node_name_arguments(call_node) ⇒ Object

:nodoc:



246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 246

def call_node_name_arguments(call_node) # :nodoc:
  return [] unless call_node.arguments
  call_node.arguments.arguments.map do |arg|
    case arg
    when Prism::SymbolNode
      arg.value
    when Prism::StringNode
      arg.unescaped
    end
  end || []
end

#change_method_to_module_function(names) ⇒ Object

Handles ‘module_function :foo, :bar`



426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 426

def change_method_to_module_function(names)
  @container.set_visibility_for(names, :private, false)
  new_methods = []
  @container.methods_matching(names) do |m|
    s_m = m.dup
    record_location(s_m)
    s_m.singleton = true
    new_methods << s_m
  end
  new_methods.each do |method|
    case method
    when RDoc::AnyMethod then
      @container.add_method(method)
    when RDoc::Attr then
      @container.add_attribute(method)
    end
    method.visibility = :public
  end
end

#change_method_visibility(names, visibility, singleton: @singleton) ⇒ Object

Handles ‘public :foo, :bar` `private :foo, :bar` and `protected :foo, :bar`



402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 402

def change_method_visibility(names, visibility, singleton: @singleton)
  new_methods = []
  @container.methods_matching(names, singleton) do |m|
    if m.parent != @container
      m = m.dup
      record_location(m)
      new_methods << m
    else
      m.visibility = visibility
    end
  end
  new_methods.each do |method|
    case method
    when RDoc::AnyMethod then
      @container.add_method(method)
    when RDoc::Attr then
      @container.add_attribute(method)
    end
    method.visibility = visibility
  end
end

#consecutive_comment(line_no) ⇒ Object

Returns consecutive comment linked to the given line number



367
368
369
370
371
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 367

def consecutive_comment(line_no)
  if @unprocessed_comments.first&.first == line_no
    @unprocessed_comments.shift.last
  end
end

#file_line_comment_token(line_no) ⇒ Object

:nodoc:



381
382
383
384
385
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 381

def file_line_comment_token(line_no) # :nodoc:
  position_comment = RDoc::Parser::RipperStateLex::Token.new(line_no - 1, 0, :on_comment)
  position_comment[:text] = "# File #{@top_level.relative_name}, line #{line_no}"
  position_comment
end

#find_or_create_constant_owner_name(constant_path) ⇒ Object

Returns a pair of owner module and constant name from a given constant path. Creates owner module if it does not exist.



619
620
621
622
623
624
625
626
627
628
629
630
631
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 619

def find_or_create_constant_owner_name(constant_path)
  const_path, colon, name = constant_path.rpartition('::')
  if colon.empty? # class Foo
    # Within `class C` or `module C`, owner is C(== current container)
    # Within `class <<C`, owner is C.singleton_class
    # but RDoc don't track constants of a singleton class of module
    [(@singleton ? nil : @container), name]
  elsif const_path.empty? # class ::Foo
    [@top_level, name]
  else # `class Foo::Bar` or `class ::Foo::Bar`
    [find_or_create_module_path(const_path, :module), name]
  end
end

#find_or_create_module_path(module_name, create_mode) ⇒ Object

Find or create module or class from a given module name. If module or class does not exist, creates a module or a class according to ‘create_mode` argument.



570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 570

def find_or_create_module_path(module_name, create_mode)
  root_name, *path, name = module_name.split('::')
  add_module = ->(mod, name, mode) {
    case mode
    when :class
      mod.add_class(RDoc::NormalClass, name, 'Object').tap { |m| m.store = @store }
    when :module
      mod.add_module(RDoc::NormalModule, name).tap { |m| m.store = @store }
    end
  }
  if root_name.empty?
    mod = @top_level
  else
    @module_nesting.reverse_each do |nesting, singleton|
      next if singleton
      mod = nesting.find_module_named(root_name)
      break if mod
      # If a constant is found and it is not a module or class, RDoc can't document about it.
      # Return an anonymous module to avoid wrong document creation.
      return RDoc::NormalModule.new(nil) if nesting.find_constant_named(root_name)
    end
    last_nesting, = @module_nesting.reverse_each.find { |_, singleton| !singleton }
    return mod || add_module.call(last_nesting, root_name, create_mode) unless name
    mod ||= add_module.call(last_nesting, root_name, :module)
  end
  path.each do |name|
    mod = mod.find_module_named(name) || add_module.call(mod, name, :module)
  end
  mod.find_module_named(name) || add_module.call(mod, name, create_mode)
end

#handle_consecutive_comment_directive(code_object, comment) ⇒ Object

:nodoc:



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 229

def handle_consecutive_comment_directive(code_object, comment) # :nodoc:
  return unless comment
  @preprocess.handle(comment, code_object) do |directive, param|
    case directive
    when 'method', 'singleton-method',
         'attr', 'attr_accessor', 'attr_reader', 'attr_writer' then
      # handled elsewhere
      ''
    when 'section' then
      @container.set_current_section(param, comment.dup)
      comment.text = ''
      break
    end
  end
  comment.remove_private
end

#handle_meta_method_comment(comment, node) ⇒ Object

Handles meta method comments



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
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 260

def handle_meta_method_comment(comment, node)
  is_call_node = node.is_a?(Prism::CallNode)
  singleton_method = false
  visibility = @visibility
  attributes = rw = line_no = method_name = nil

  processed_comment = comment.dup
  @preprocess.handle(processed_comment, @container) do |directive, param, line|
    case directive
    when 'attr', 'attr_reader', 'attr_writer', 'attr_accessor'
      attributes = [param] if param
      attributes ||= call_node_name_arguments(node) if is_call_node
      rw = directive == 'attr_writer' ? 'W' : directive == 'attr_accessor' ? 'RW' : 'R'
      ''
    when 'method'
      method_name = param
      line_no = line
      ''
    when 'singleton-method'
      method_name = param
      line_no = line
      singleton_method = true
      visibility = :public
      ''
    when 'section' then
      @container.set_current_section(param, comment.dup)
      return # If the comment contains :section:, it is not a meta method comment
    end
  end

  if attributes
    attributes.each do |attr|
      a = RDoc::Attr.new(@container, attr, rw, processed_comment, singleton: @singleton)
      a.store = @store
      a.line = line_no
      record_location(a)
      @container.add_attribute(a)
      a.visibility = visibility
    end
  elsif line_no || node
    method_name ||= call_node_name_arguments(node).first if is_call_node
    meth = RDoc::AnyMethod.new(@container, method_name, singleton: @singleton || singleton_method)
    handle_consecutive_comment_directive(meth, comment)
    comment.normalize
    meth.call_seq = comment.extract_call_seq
    meth.comment = comment
    if node
      tokens = visible_tokens_from_location(node.location)
      line_no = node.location.start_line
    else
      tokens = [file_line_comment_token(line_no)]
    end
    internal_add_method(
      @container,
      meth,
      line_no: line_no,
      visibility: visibility,
      params: '()',
      calls_super: false,
      block_params: nil,
      tokens: tokens
    )
  end
end

#handle_modifier_directive(code_object, line_no) ⇒ Object

:nodoc:



224
225
226
227
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 224

def handle_modifier_directive(code_object, line_no) # :nodoc:
  comment = @modifier_comments[line_no]
  @preprocess.handle(comment.text, code_object) if comment
end

#handle_standalone_consecutive_comment_directive(comment, line_no, start_line) ⇒ Object

:nodoc:



331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 331

def handle_standalone_consecutive_comment_directive(comment, line_no, start_line) # :nodoc:
  if @markup == 'tomdoc'
    parse_comment_tomdoc(@container, comment, line_no, start_line)
    return
  end

  if comment.text =~ /\A#\#$/ && comment != @first_non_meta_comment
    node = @line_nodes[line_no]
    handle_meta_method_comment(comment, node)
  elsif normal_comment_treat_as_ghost_method_for_now?(comment.text, line_no) && comment != @first_non_meta_comment
    handle_meta_method_comment(comment, nil)
  else
    handle_consecutive_comment_directive(@container, comment)
  end
end

#has_modifier_nodoc?(line_no) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


220
221
222
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 220

def has_modifier_nodoc?(line_no) # :nodoc:
  @modifier_comments[line_no]&.text&.match?(/\A#\s*:nodoc:/)
end

#normal_comment_treat_as_ghost_method_for_now?(comment_text, line_no) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


325
326
327
328
329
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 325

def normal_comment_treat_as_ghost_method_for_now?(comment_text, line_no) # :nodoc:
  # Meta method comment should start with `##` but some comments does not follow this rule.
  # For now, RDoc accepts them as a meta method comment if there is no node linked to it.
  !@line_nodes[line_no] && comment_text.match?(/^#\s+:(method|singleton-method|attr|attr_reader|attr_writer|attr_accessor):/)
end

#parse_comment_tomdoc(container, comment, line_no, start_line) ⇒ Object

Creates an RDoc::Method on container from comment if there is a Signature section in the comment



197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 197

def parse_comment_tomdoc(container, comment, line_no, start_line)
  return unless signature = RDoc::TomDoc.signature(comment)

  name, = signature.split %r%[ \(]%, 2

  meth = RDoc::GhostMethod.new comment.text, name
  record_location(meth)
  meth.line = start_line
  meth.call_seq = signature
  return unless meth.name

  meth.start_collecting_tokens
  node = @line_nodes[line_no]
  tokens = node ? visible_tokens_from_location(node.location) : [file_line_comment_token(start_line)]
  tokens.each { |token| meth.token_stream << token }

  container.add_method meth
  comment.remove_private
  comment.normalize
  meth.comment = comment
  @stats.add_method meth
end

#prepare_comments(comments) ⇒ Object

Prepares comments for processing. Comments are grouped into consecutive. Consecutive comment is linked to the next non-blank line.

Example:

01| class A # modifier comment 1
02|   def foo; end # modifier comment 2
03|
04|   # consecutive comment 1 start_line: 4
05|   # consecutive comment 1 linked to line: 7
06|
07|   # consecutive comment 2 start_line: 7
08|   # consecutive comment 2 linked to line: 10
09|
10|   def bar; end # consecutive comment 2 linked to this line
11| end



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
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 145

def prepare_comments(comments)
  current = []
  consecutive_comments = [current]
  @modifier_comments = {}
  comments.each do |comment|
    if comment.is_a? Prism::EmbDocComment
      consecutive_comments << [comment] << (current = [])
    elsif comment.location.start_line_slice.match?(/\S/)
      @modifier_comments[comment.location.start_line] = RDoc::Comment.new(comment.slice, @top_level, :ruby)
    elsif current.empty? || current.last.location.end_line + 1 == comment.location.start_line
      current << comment
    else
      consecutive_comments << (current = [comment])
    end
  end
  consecutive_comments.reject!(&:empty?)

  # Example: line_no = 5, start_line = 2, comment_text = "# comment_start_line\n# comment\n"
  # 1| class A
  # 2|   # comment_start_line
  # 3|   # comment
  # 4|
  # 5|   def f; end # comment linked to this line
  # 6| end
  @unprocessed_comments = consecutive_comments.map! do |comments|
    start_line = comments.first.location.start_line
    line_no = comments.last.location.end_line + (comments.last.location.end_column == 0 ? 0 : 1)
    texts = comments.map do |c|
      c.is_a?(Prism::EmbDocComment) ? c.slice.lines[1...-1].join : c.slice
    end
    text = RDoc::Encoding.change_encoding(texts.join("\n"), @encoding) if @encoding
    line_no += 1 while @lines[line_no - 1]&.match?(/\A\s*$/)
    comment = RDoc::Comment.new(text, @top_level, :ruby)
    comment.line = start_line
    [line_no, start_line, comment]
  end

  # The first comment is special. It defines markup for the rest of the comments.
  _, first_comment_start_line, first_comment_text = @unprocessed_comments.first
  if first_comment_text && @lines[0...first_comment_start_line - 1].all? { |l| l.match?(/\A\s*$/) }
    comment = RDoc::Comment.new(first_comment_text.text, @top_level, :ruby)
    handle_consecutive_comment_directive(@container, comment)
    @markup = comment.format
  end
  @unprocessed_comments.each do |_, _, comment|
    comment.format = @markup
  end
end

#prepare_line_nodes(node) ⇒ Object

Assign AST node to a line. This is used to show meta-method source code in the documentation.



119
120
121
122
123
124
125
126
127
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 119

def prepare_line_nodes(node) # :nodoc:
  case node
  when Prism::CallNode, Prism::DefNode
    @line_nodes[node.location.start_line] ||= node
  end
  node.compact_child_nodes.each do |child|
    prepare_line_nodes(child)
  end
end

#process_comments_until(line_no_until) ⇒ Object

Processes consecutive comments that were not linked to any documentable code until the given line number



349
350
351
352
353
354
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 349

def process_comments_until(line_no_until)
  while !@unprocessed_comments.empty? && @unprocessed_comments.first[0] <= line_no_until
    line_no, start_line, rdoc_comment = @unprocessed_comments.shift
    handle_standalone_consecutive_comment_directive(rdoc_comment, line_no, start_line)
  end
end

#record_location(container) ⇒ Object

Records the location of this container in the file for this parser and adds it to the list of classes and modules in the file.



80
81
82
83
84
85
86
87
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 80

def record_location(container) # :nodoc:
  case container
  when RDoc::ClassModule then
    @top_level.add_to_classes_or_modules container
  end

  container.record_location @top_level
end

#resolve_constant_path(constant_path) ⇒ Object

Resolves constant path to a full path by searching module nesting



603
604
605
606
607
608
609
610
611
612
613
614
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 603

def resolve_constant_path(constant_path)
  owner_name, path = constant_path.split('::', 2)
  return constant_path if owner_name.empty? # ::Foo, ::Foo::Bar
  mod = nil
  @module_nesting.reverse_each do |nesting, singleton|
    next if singleton
    mod = nesting.find_module_named(owner_name)
    break if mod
  end
  mod ||= @top_level.find_module_named(owner_name)
  [mod.full_name, path].compact.join('::') if mod
end

#scan ⇒ Object

Scans this Ruby file for Ruby constructs



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 91

def scan
  @tokens = RDoc::Parser::RipperStateLex.parse(@content)
  @lines = @content.lines
  result = Prism.parse(@content)
  @program_node = result.value
  @line_nodes = {}
  prepare_line_nodes(@program_node)
  prepare_comments(result.comments)
  return if @top_level.done_documenting

  @first_non_meta_comment = nil
  if (_line_no, start_line, rdoc_comment = @unprocessed_comments.first)
    @first_non_meta_comment = rdoc_comment if start_line < @program_node.location.start_line
  end

  @program_node.accept(RDocVisitor.new(self, @top_level, @store))
  process_comments_until(@lines.size + 1)
end

#should_document?(code_object) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


110
111
112
113
114
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 110

def should_document?(code_object) # :nodoc:
  return true unless @track_visibility
  return false if code_object.parent&.document_children == false
  code_object.document_self
end

#skip_comments_until(line_no_until) ⇒ Object

Skips all undocumentable consecutive comments until the given line number. Undocumentable comments are comments written inside ‘def` or inside undocumentable class/module



359
360
361
362
363
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 359

def skip_comments_until(line_no_until)
  while !@unprocessed_comments.empty? && @unprocessed_comments.first[0] <= line_no_until
    @unprocessed_comments.shift
  end
end

#slice_tokens(start_pos, end_pos) ⇒ Object

:nodoc:



373
374
375
376
377
378
379
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 373

def slice_tokens(start_pos, end_pos) # :nodoc:
  start_index = @tokens.bsearch_index { |t| ([t.line_no, t.char_no] <=> start_pos) >= 0 }
  end_index = @tokens.bsearch_index { |t| ([t.line_no, t.char_no] <=> end_pos) >= 0 }
  tokens = @tokens[start_index...end_index]
  tokens.pop if tokens.last&.kind == :on_nl
  tokens
end

#visible_tokens_from_location(location) ⇒ Object

Returns tokens from the given location



389
390
391
392
393
394
395
396
397
398
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 389

def visible_tokens_from_location(location)
  position_comment = file_line_comment_token(location.start_line)
  newline_token = RDoc::Parser::RipperStateLex::Token.new(0, 0, :on_nl, "\n")
  indent_token = RDoc::Parser::RipperStateLex::Token.new(location.start_line, 0, :on_sp, ' ' * location.start_character_column)
  tokens = slice_tokens(
    [location.start_line, location.start_character_column],
    [location.end_line, location.end_character_column]
  )
  [position_comment, newline_token, indent_token, *tokens]
end

#with_container(container, singleton: false) ⇒ Object

Dive into another container



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 53

def with_container(container, singleton: false)
  old_container = @container
  old_visibility = @visibility
  old_singleton = @singleton
  old_in_proc_block = @in_proc_block
  @visibility = :public
  @container = container
  @singleton = singleton
  @in_proc_block = false
  unless singleton
    # Need to update module parent chain to emulate Module.nesting.
    # This mechanism is inaccurate and needs to be fixed.
    container.parent = old_container
  end
  @module_nesting.push([container, singleton])
  yield container
ensure
  @container = old_container
  @visibility = old_visibility
  @singleton = old_singleton
  @in_proc_block = old_in_proc_block
  @module_nesting.pop
end

#with_in_proc_block ⇒ Object

Suppress ‘extend` and `include` within block because they might be a metaprogramming block example: `Module.new { include M }` `M.module_eval { include N }`



45
46
47
48
49
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 45

def with_in_proc_block
  @in_proc_block = true
  yield
  @in_proc_block = false
end