Class: RDoc::Parser::Ruby

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

Overview

Extracts code elements from a source file returning a TopLevel object containing the constituent file elements.

RubyParser understands how to document:

  • classes

  • modules

  • methods

  • constants

  • aliases

  • private, public, protected

  • private_class_function, public_class_function

  • private_constant, public_constant

  • module_function

  • attr, attr_reader, attr_writer, attr_accessor

  • extra accessors given on the command line

  • metaprogrammed methods

  • require

  • include

Method Arguments

The parser extracts the arguments from the method definition. You can override this with a custom argument definition using the :args: directive:

##
# This method tries over and over until it is tired

def go_go_go(thing_to_try, tries = 10) # :args: thing_to_try
  puts thing_to_try
  go_go_go thing_to_try, tries - 1
end

If you have a more-complex set of overrides you can use the :call-seq: directive:

##
# This method can be called with a range or an offset and length
#
# :call-seq:
#   my_method(Range)
#   my_method(offset, length)

def my_method(*args)
end

The parser extracts yield expressions from method bodies to gather the yielded argument names. If your method manually calls a block instead of yielding or you want to override the discovered argument names use the :yields: directive:

##
# My method is awesome

def my_method(&block) # :yields: happy, times
  block.call 1, 2
end

Metaprogrammed Methods

To pick up a metaprogrammed method, the parser looks for a comment starting with ‘##’ before a metaprogramming method call:

##
# This is a meta-programmed method!

add_my_method :meta_method, :arg1, :arg2

The parser looks at the first argument to determine the name, in this example, :meta_method. If a name cannot be found, a warning is printed and ‘unknown’ is used.

You can force the name of a method using the :method: directive:

##
# :method: some_method!

By default, meta-methods are instance methods. To indicate that a method is a singleton method instead use the :singleton-method: directive:

##
# :singleton-method:

You can also use the :singleton-method: directive with a name:

##
# :singleton-method: some_method!

You can define arguments for metaprogrammed methods via either the :call-seq:, :arg: or :args: directives.

Additionally you can mark a method as an attribute by using :attr:, :attr_reader:, :attr_writer: or :attr_accessor:. Just like for :method:, the name is optional.

##
# :attr_reader: my_attr_name

Hidden methods and attributes

You can provide documentation for methods that don’t appear using the :method:, :singleton-method: and :attr: directives:

##
# :attr_writer: ghost_writer
# There is an attribute here, but you can't see it!

##
# :method: ghost_method
# There is a method here, but you can't see it!

##
# this is a comment for a regular method

def regular_method() end

Note that by default, the :method: directive will be ignored if there is a standard rdocable item following it.

Defined Under Namespace

Classes: RDocVisitor

Constant Summary collapse

RBS_SIG_LINE =

Matches an RBS inline type annotation line: #: followed by whitespace

/\A#:\s/

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) ⇒ Ruby

Returns a new instance of Ruby.



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/rdoc/parser/ruby.rb', line 137

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.



135
136
137
 
# File 'lib/rdoc/parser/ruby.rb', line 135

def container
  @container
end

#in_proc_block ⇒ Object (readonly)

Returns the value of attribute in_proc_block.



135
136
137
 
# File 'lib/rdoc/parser/ruby.rb', line 135

def in_proc_block
  @in_proc_block
end

#singleton ⇒ Object (readonly)

Returns the value of attribute singleton.



135
136
137
 
# File 'lib/rdoc/parser/ruby.rb', line 135

def singleton
  @singleton
end

#visibility ⇒ Object

Returns the value of attribute visibility.



134
135
136
 
# File 'lib/rdoc/parser/ruby.rb', line 134

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`



561
562
563
564
565
566
567
568
569
570
571
572
573
574
 
# File 'lib/rdoc/parser/ruby.rb', line 561

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



578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
 
# File 'lib/rdoc/parser/ruby.rb', line 578

def add_attributes(names, rw, line_no)
  comment, directives, type_signature_lines = 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(symbol.to_s, rw, comment, singleton: @singleton)
    a.store = @store
    a.line = line_no
    a.type_signature_lines = type_signature_lines
    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, alias_path: nil) ⇒ Object

Adds a constant



756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
 
# File 'lib/rdoc/parser/ruby.rb', line 756

def add_constant(constant_name, rhs_name, start_line, end_line, alias_path: nil)
  comment, directives = consecutive_comment(start_line)
  handle_code_object_directives(@container, directives) if directives
  owner, name = find_or_create_lexical_constant_owner_name(constant_name)
  return unless owner

  constant = RDoc::Constant.new(name, rhs_name, comment)
  constant.store = @store
  constant.line = start_line
  constant.is_alias_for_path = alias_path
  record_location(constant)
  handle_modifier_directive(constant, start_line)
  handle_modifier_directive(constant, end_line)
  owner.add_constant(constant)
  return unless alias_path
  mod =
    if alias_path.start_with?('::')
      @store.find_class_or_module(alias_path)
    else
      full_name = resolve_constant_path(alias_path)
      @store.find_class_or_module(full_name)
    end
  if mod && constant.document_self
    a = owner.add_module_alias(mod, alias_path, 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`



618
619
620
 
# File 'lib/rdoc/parser/ruby.rb', line 618

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`



612
613
614
 
# File 'lib/rdoc/parser/ruby.rb', line 612

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.



597
598
599
600
601
602
603
604
605
606
607
608
 
# File 'lib/rdoc/parser/ruby.rb', line 597

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



624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
 
# File 'lib/rdoc/parser/ruby.rb', line 624

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_lexical_module_path(receiver_name, receiver_fallback_type) : @container
  comment, directives, type_signature_lines = 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,
    type_signature_lines: type_signature_lines
  )
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



788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
 
# File 'lib/rdoc/parser/ruby.rb', line 788

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_lexical_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:



341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/rdoc/parser/ruby.rb', line 341

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`



533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
 
# File 'lib/rdoc/parser/ruby.rb', line 533

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`



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

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



461
462
463
464
465
 
# File 'lib/rdoc/parser/ruby.rb', line 461

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

#extract_section_comment(comment_text, prefix_line_count) ⇒ Object

Extracts the comment for this section from the normalized comment block. Removes all lines before the line that contains :section: If the comment also ends with the same content, remove it as well



493
494
495
496
497
498
499
 
# File 'lib/rdoc/parser/ruby.rb', line 493

def extract_section_comment(comment_text, prefix_line_count) # :nodoc:
  prefix = comment_text.lines[0...prefix_line_count].join
  comment_text.delete_prefix!(prefix)
  # Comment is already normalized and doesn't end with a newline
  comment_text.delete_suffix!(prefix.chomp)
  comment_text
end

#find_or_create_lexical_constant_owner_name(constant_path) ⇒ Object

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



740
741
742
743
744
745
746
747
748
749
750
751
752
 
# File 'lib/rdoc/parser/ruby.rb', line 740

def find_or_create_lexical_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_lexical_module_path(const_path, :module), name]
  end
end

#find_or_create_lexical_module_path(module_name, create_mode) ⇒ Object

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



691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
 
# File 'lib/rdoc/parser/ruby.rb', line 691

def find_or_create_lexical_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:



553
554
555
556
557
 
# File 'lib/rdoc/parser/ruby.rb', line 553

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



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

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(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 = syntax_highlighted_tokens(node)
      line_no = node.location.start_line
    else
      tokens = []
    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:



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

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:



423
424
425
426
427
428
429
430
431
432
 
# File 'lib/rdoc/parser/ruby.rb', line 423

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) 


330
331
332
 
# File 'lib/rdoc/parser/ruby.rb', line 330

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) 


417
418
419
420
421
 
# File 'lib/rdoc/parser/ruby.rb', line 417

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 returns [RDoc::Comment, directives, type_signature_lines], or nil if the comment is a section header (which has no associated code object).



471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
 
# File 'lib/rdoc/parser/ruby.rb', line 471

def parse_comment_text_to_directives(comment_text, start_line) # :nodoc:
  type_signature_lines = extract_type_signature!(comment_text, start_line)
  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, directive_line = directives['section'])
    # If comment has :section:, it is not a documentable comment for a code object
    comment.text = extract_section_comment(comment_text, directive_line - start_line)
    @container.set_current_section(section, comment)
    return
  end
  @preprocess.run_post_processes(comment, @container)
  [comment, directives, type_signature_lines]
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



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

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

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

  meth = RDoc::AnyMethod.new 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 ? syntax_highlighted_tokens(node) : []
  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



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

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.



233
234
235
236
237
238
239
240
241
 
# File 'lib/rdoc/parser/ruby.rb', line 233

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



436
437
438
439
440
441
442
443
444
445
446
447
448
 
# File 'lib/rdoc/parser/ruby.rb', line 436

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.



192
193
194
195
196
197
198
199
 
# File 'lib/rdoc/parser/ruby.rb', line 192

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



724
725
726
727
728
729
730
731
732
733
734
735
 
# File 'lib/rdoc/parser/ruby.rb', line 724

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



203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/rdoc/parser/ruby.rb', line 203

def scan
  @lines = @content.lines
  result = Prism.parse_lex(@content)
  @program_node, unordered_tokens = result.value
  # Heredoc tokens are not in start_offset order.
  # Need to sort them to use bsearch for finding tokens from location.
  @prism_tokens = unordered_tokens.map(&:first).sort_by { |t| t.location.start_offset }
  @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) 


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

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



453
454
455
456
457
 
# File 'lib/rdoc/parser/ruby.rb', line 453

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

#syntax_highlighted_tokens(node) ⇒ Object

Returns syntax highlighted tokens of the given node



503
504
505
 
# File 'lib/rdoc/parser/ruby.rb', line 503

def syntax_highlighted_tokens(node)
  RDoc::Parser::RubyColorizer.partial_colorize(@content, node, @prism_tokens)
end

#with_container(container, singleton: false) ⇒ Object

Dive into another container



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/rdoc/parser/ruby.rb', line 170

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



161
162
163
164
165
166
 
# File 'lib/rdoc/parser/ruby.rb', line 161

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