Class: RDoc::Markup::PreProcess

# File 'lib/rdoc/markup/pre_process.rb', line 39

def self.post_processors
  @post_processors
end

# File 'lib/rdoc/markup/pre_process.rb', line 55

def self.register(directive, &block)
  @registered[directive] = block
end

# File 'lib/rdoc/markup/pre_process.rb', line 62

def self.registered
  @registered
end

# File 'lib/rdoc/markup/pre_process.rb', line 69

def self.reset
  @post_processors = []
  @registered = {}
end

# File 'lib/rdoc/markup/pre_process.rb', line 101

def handle(text, code_object = nil, &block)
  if Comment === text
    comment = text
    text = text.text
  end

  # regexp helper (square brackets for optional)
  # $1      $2  $3        $4      $5
  # [prefix][\]:directive:[spaces][param]newline
  text = text.gsub(/^([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):([\w-]+):([ \t]*)(.+)?(\r?\n|$)/) do
    # skip something like ':toto::'
    next $& if $4.empty? and $5 and $5[0, 1] == ':'

    # skip if escaped
    next "#$1:#$3:#$4#$5\n" unless $2.empty?

    # This is not in handle_directive because I didn't want to pass another
    # argument into it
    if comment and $3 == 'markup'
      next "#{$1.strip}\n" unless $5
      comment.format = $5.downcase
      next "#{$1.strip}\n"
    end
    handle_directive $1, $3, $5, code_object, text.encoding, &block
  end

  if comment
    comment.text = text
  else
    comment = text
  end

  run_post_processes(comment, code_object)

  text
end

# File 'lib/rdoc/markup/pre_process.rb', line 179

def handle_directive(prefix, directive, param, code_object = nil,
                     encoding = nil)
  blankline = "#{prefix.strip}\n"
  directive = directive.downcase

  case directive
  when 'arg', 'args'
    return "#{prefix}:#{directive}: #{param}\n" unless code_object && code_object.kind_of?(AnyMethod)

    code_object.params = param

    blankline
  when 'category'
    if Context === code_object
      section = code_object.add_section param
      code_object.temporary_section = section
    elsif AnyMethod === code_object
      code_object.section_title = param
    end

    blankline # ignore category if we're not on an RDoc::Context
  when 'doc'
    return blankline unless code_object
    code_object.document_self = true
    code_object.force_documentation = true

    blankline
  when 'enddoc'
    return blankline unless code_object
    code_object.done_documenting = true

    blankline
  when 'include'
    filename = param.split(' ', 2).first
    include_file filename, prefix, encoding
  when 'nodoc'
    return blankline unless code_object
    code_object.document_self = nil # notify nodoc
    code_object.document_children = param !~ /all/i

    blankline
  when 'notnew', 'not_new', 'not-new'
    return blankline unless AnyMethod === code_object

    code_object.dont_rename_initialize = true

    blankline
  when 'startdoc'
    return blankline unless code_object

    code_object.start_doc
    code_object.force_documentation = true

    blankline
  when 'stopdoc'
    return blankline unless code_object

    code_object.stop_doc

    blankline
  when 'yield', 'yields'
    return blankline unless code_object
    # remove parameter &block
    code_object.params = code_object.params.sub(/,?\s*&\w+/, '') if code_object.params

    code_object.block_params = param || ''

    blankline
  else
    result = yield directive, param if block_given?

    case result
    when nil
      code_object.metadata[directive] = param if code_object

      if Markup::PreProcess.registered.include? directive
        handler = Markup::PreProcess.registered[directive]
        result = handler.call directive, param if handler
      else
        result = "#{prefix}:#{directive}: #{param}\n"
      end
    when false
      result = "#{prefix}:#{directive}: #{param}\n"
    end

    result
  end
end

# File 'lib/rdoc/markup/pre_process.rb', line 283

def include_file(name, indent, encoding)
  full_name = find_include_file name

  unless full_name
    warn "Couldn't find file to include '#{name}' from #{@input_file_name}"
    return ''
  end

  content = Encoding.read_file full_name, encoding, true
  content = Encoding.remove_magic_comment content

  # strip magic comment
  content = content.sub(/\A# .*coding[=:].*$/, '').lstrip

  # strip leading '#'s, but only if all lines start with them
  if content =~ /^[^#]/
    content.gsub(/^/, indent)
  else
    content.gsub(/^#?/, indent)
  end
end

# File 'lib/rdoc/markup/pre_process.rb', line 162

def parse_comment(text, line_no, type)
  Comment.parse(text, @input_file_name, line_no, type) do |filename, prefix_indent|
    include_file(filename, prefix_indent, text.encoding)
  end
end

# File 'lib/rdoc/markup/pre_process.rb', line 154

def run_post_processes(comment, code_object)
  self.class.post_processors.each do |handler|
    handler.call comment, code_object
  end
end

# File 'lib/rdoc/markup/pre_process.rb', line 140

def run_pre_processes(comment_text, code_object, start_line_no, type)
  comment_text, directives = parse_comment(comment_text, start_line_no, type)
  directives.each do |directive, (param, line_no)|
    handle_directive('', directive, param, code_object)
  end
  if code_object.is_a?(AnyMethod) && (call_seq, = directives['call-seq']) && call_seq
    code_object.call_seq = call_seq.lines.map(&:chomp).reject(&:empty?).join("\n")
  end
  format, = directives['markup']
  [comment_text, format]
end