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

#in_proc_block ⇒ Object (readonly)

Returns the value of attribute in_proc_block.



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

def in_proc_block
  @in_proc_block
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, directives = consecutive_comment(line_no)
  handle_code_object_directives(@container, directives) if directives
  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, directives = consecutive_comment(line_no)
  handle_code_object_directives(@container, directives) if directives
  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



639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 639

def add_constant(constant_name, rhs_name, start_line, end_line)
  comment, directives = consecutive_comment(start_line)
  handle_code_object_directives(@container, directives) if directives
  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
      full_name = resolve_constant_path(rhs_name)
      @store.find_class_or_module(full_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`



504
505
506
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 504

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`



498
499
500
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 498

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

Adds includes/extends. Module name is resolved to full before adding.



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

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

#add_method(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



510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 510

def add_method(method_name, receiver_name:, receiver_fallback_type:, visibility:, singleton:, params:, calls_super:, block_params:, tokens:, start_line:, args_end_line:, end_line:)
  receiver = receiver_name ? find_or_create_module_path(receiver_name, receiver_fallback_type) : @container
  comment, directives = consecutive_comment(start_line)
  handle_code_object_directives(@container, directives) if directives

  internal_add_method(
    method_name,
    receiver,
    comment: comment,
    directives: directives,
    modifier_comment_lines: [start_line, args_end_line, end_line].uniq,
    line_no: start_line,
    visibility: visibility,
    singleton: singleton,
    params: params,
    calls_super: calls_super,
    block_params: block_params,
    tokens: tokens
  )
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



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
702
703
704
705
706
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 669

def add_module_or_class(module_name, start_line, end_line, is_class: false, superclass_name: nil, superclass_expr: nil)
  comment, directives = consecutive_comment(start_line)
  handle_code_object_directives(@container, directives) if directives
  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:



223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 223

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`



420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 420

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`



396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 396

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



343
344
345
346
347
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 343

def consecutive_comment(line_no)
  return unless @unprocessed_comments.first&.first == line_no
  _line_no, start_line, text = @unprocessed_comments.shift
  parse_comment_text_to_directives(text, start_line)
end

#file_line_comment_token(line_no) ⇒ Object

:nodoc:



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

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.



623
624
625
626
627
628
629
630
631
632
633
634
635
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 623

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.



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
600
601
602
603
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 574

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.get_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.get_module_named(name) || add_module.call(mod, name, :module)
  end
  mod.get_module_named(name) || add_module.call(mod, name, create_mode)
end

#handle_code_object_directives(code_object, directives) ⇒ Object

:nodoc:



440
441
442
443
444
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 440

def handle_code_object_directives(code_object, directives) # :nodoc:
  directives.each do |directive, (param)|
    @preprocess.handle_directive('', directive, param, code_object)
  end
end

#handle_meta_method_comment(comment, directives, node) ⇒ Object

Handles meta method comments



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

def handle_meta_method_comment(comment, directives, node)
  handle_code_object_directives(@container, directives)
  is_call_node = node.is_a?(Prism::CallNode)
  singleton_method = false
  visibility = @visibility
  attributes = rw = line_no = method_name = nil
  directives.each 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 if param
      line_no = line
    when 'singleton-method'
      method_name = param if param
      line_no = line
      singleton_method = true
      visibility = :public
    end
  end

  if attributes
    attributes.each do |attr|
      a = RDoc::Attr.new(@container, attr, rw, 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
    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(
      method_name,
      @container,
      comment: comment,
      directives: directives,
      dont_rename_initialize: false,
      line_no: line_no,
      visibility: visibility,
      singleton: @singleton || singleton_method,
      params: nil,
      calls_super: false,
      block_params: nil,
      tokens: tokens,
    )
  end
end

#handle_modifier_directive(code_object, line_no) ⇒ Object

:nodoc:



216
217
218
219
220
221
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 216

def handle_modifier_directive(code_object, line_no) # :nodoc:
  if (comment_text = @modifier_comments[line_no])
    _text, directives = @preprocess.parse_comment(comment_text, line_no, :ruby)
    handle_code_object_directives(code_object, directives)
  end
end

#handle_standalone_consecutive_comment_directive(comment, directives, start_with_sharp_sharp, line_no, start_line) ⇒ Object

:nodoc:



305
306
307
308
309
310
311
312
313
314
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 305

def handle_standalone_consecutive_comment_directive(comment, directives, start_with_sharp_sharp, line_no, start_line) # :nodoc:
  if start_with_sharp_sharp && start_line != @first_non_meta_comment_start_line
    node = @line_nodes[line_no]
    handle_meta_method_comment(comment, directives, node)
  elsif normal_comment_treat_as_ghost_method_for_now?(directives, line_no) && start_line != @first_non_meta_comment_start_line
    handle_meta_method_comment(comment, directives, nil)
  else
    handle_code_object_directives(@container, directives)
  end
end

#has_modifier_nodoc?(line_no) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


212
213
214
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 212

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

#normal_comment_treat_as_ghost_method_for_now?(directives, line_no) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


299
300
301
302
303
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 299

def normal_comment_treat_as_ghost_method_for_now?(directives, 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] && INVALID_GHOST_METHOD_ACCEPT_DIRECTIVE_LIST.any? { |directive| directives.has_key?(directive) }
end

#parse_comment_text_to_directives(comment_text, start_line) ⇒ Object

Parses comment text and retuns a pair of RDoc::Comment and directives



351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 351

def parse_comment_text_to_directives(comment_text, start_line) # :nodoc:
  comment_text, directives = @preprocess.parse_comment(comment_text, start_line, :ruby)
  comment = RDoc::Comment.new(comment_text, @top_level, :ruby)
  comment.normalized = true
  comment.line = start_line
  markup, = directives['markup']
  comment.format = markup&.downcase || @markup
  if (section, = directives['section'])
    # If comment has :section:, it is not a documentable comment for a code object
    @container.set_current_section(section, comment.dup)
    return
  end
  @preprocess.run_post_processes(comment, @container)
  [comment, directives]
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



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 191

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(:ruby)
  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
  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



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

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/)
      text = comment.slice
      text = RDoc::Encoding.change_encoding(text, @encoding) if @encoding
      @modifier_comments[comment.location.start_line] = text
    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 = texts.join("\n")
    text = RDoc::Encoding.change_encoding(text, @encoding) if @encoding
    line_no += 1 while @lines[line_no - 1]&.match?(/\A\s*$/)
    [line_no, start_line, text]
  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*$/) }
    _text, directives = @preprocess.parse_comment(first_comment_text, first_comment_start_line, :ruby)
    markup, = directives['markup']
    @markup = markup.downcase if 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.



115
116
117
118
119
120
121
122
123
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 115

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



318
319
320
321
322
323
324
325
326
327
328
329
330
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 318

def process_comments_until(line_no_until)
  while !@unprocessed_comments.empty? && @unprocessed_comments.first[0] <= line_no_until
    line_no, start_line, text = @unprocessed_comments.shift
    if @markup == 'tomdoc'
      comment = RDoc::Comment.new(text, @top_level, :ruby)
      comment.format = 'tomdoc'
      parse_comment_tomdoc(@container, comment, line_no, start_line)
      @preprocess.run_post_processes(comment, @container)
    elsif (comment_text, directives = parse_comment_text_to_directives(text, start_line))
      handle_standalone_consecutive_comment_directive(comment_text, directives, text.start_with?(/#\#$/), line_no, start_line)
    end
  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.



76
77
78
79
80
81
82
83
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 76

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



607
608
609
610
611
612
613
614
615
616
617
618
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 607

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.get_module_named(owner_name)
    break if mod
  end
  mod ||= @top_level.get_module_named(owner_name)
  [mod.full_name, path].compact.join('::') if mod
end

#scan ⇒ Object

Scans this Ruby file for Ruby constructs



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 87

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_start_line = nil
  if (_line_no, start_line = @unprocessed_comments.first)
    @first_non_meta_comment_start_line = start_line 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) 


106
107
108
109
110
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 106

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



335
336
337
338
339
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 335

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:



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

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



383
384
385
386
387
388
389
390
391
392
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 383

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



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

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

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