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`



452
453
454
455
456
457
458
459
460
461
462
463
464
465
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 452

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`



469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 469

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



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

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
      @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`



506
507
508
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 506

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`



500
501
502
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 500

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:



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

def add_includes_extends(names, rdoc_class, line_no) # :nodoc:
  return if @in_proc_block
  comment, directives = consecutive_comment(line_no)
  handle_code_object_directives(@container, directives) if directives
  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(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



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

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:)
  return if @in_proc_block

  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



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

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:



227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 227

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`



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

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`



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

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



347
348
349
350
351
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 347

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:



379
380
381
382
383
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 379

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.



627
628
629
630
631
632
633
634
635
636
637
638
639
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 627

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.



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
604
605
606
607
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 578

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_code_object_directives(code_object, directives) ⇒ Object

:nodoc:



444
445
446
447
448
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 444

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



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

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:



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

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:



309
310
311
312
313
314
315
316
317
318
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 309

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) 


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

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) 


303
304
305
306
307
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 303

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



355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 355

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



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

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



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
 
# 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/)
      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.



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



322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 322

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.



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



611
612
613
614
615
616
617
618
619
620
621
622
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 611

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_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) 


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



339
340
341
342
343
 
# File 'lib/rdoc/parser/prism_ruby.rb', line 339

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:



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

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



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

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