Class: RDoc::Markup::InlineParser

# File 'lib/rdoc/markup/inline_parser.rb', line 92

def current
  @stack.last
end

# File 'lib/rdoc/markup/inline_parser.rb', line 178

def invalidate_open_tidylinks
  return unless @delimiters[:tidylink]

  @delimiters[:invalidated_tidylink] ||= []
  @delimiters[:tidylink].each do |idx|
    @delimiters[:invalidated_tidylink] << idx
    @stack[idx][:delimiter] = :invalidated_tidylink
  end
  @delimiters.delete(:tidylink)
end

# File 'lib/rdoc/markup/inline_parser.rb', line 104

def parse
  stack_push(:root, nil)
  while true
    type, token, value = scan_token
    close = nil
    tidylink_url = nil
    case type
    when :node
      current[:children] << value
      invalidate_open_tidylinks if value[:type] == :TIDYLINK
    when :eof
      close = :root
    when :tidylink_open
      stack_push(:tidylink, token)
    when :tidylink_close
      close = :tidylink
      if value
        tidylink_url = value
      else
        # Tidylink closing brace without URL part. Treat opening and closing braces as normal text
        # `{labelnodes}...` case.
        current[:children] << token
      end
    when :invalidated_tidylink_close
      # `{...{label}[url]...}` case. Nested tidylink invalidates outer one. The last `}` closes the invalidated tidylink.
      current[:children] << token
      close = :invalidated_tidylink
    when :text
      current[:children] << token
    when :open
      stack_push(value, token)
    when :close
      if @delimiters[value]
        close = value
      else
        # closing tag without matching opening tag. Treat as normal text.
        current[:children] << token
      end
    end

    next unless close

    while current[:delimiter] != close
      children = current[:children]
      open_token = current[:token]
      stack_pop
      current[:children] << open_token if open_token
      current[:children].concat(children)
    end

    token = current[:token]
    children = compact_string(current[:children])
    stack_pop

    return children if close == :root

    if close == :tidylink || close == :invalidated_tidylink
      if tidylink_url
        current[:children] << { type: :TIDYLINK, children: children, url: tidylink_url }
        invalidate_open_tidylinks
      else
        current[:children] << token
        current[:children].concat(children)
      end
    else
      current[:children] << { type: TAGS[close], children: children }
    end
  end
end

# File 'lib/rdoc/markup/inline_parser.rb', line 308

def read_tidylink_url
  bracketed_url = strscan(/\[([^\s\[\]\\]|\\[\[\]\\*<_])\]/)
  bracketed_url[1...-1].gsub(/\\(.)/, '\1') if bracketed_url
end

# File 'lib/rdoc/markup/inline_parser.rb', line 230

def scan_token
  last_match = @last_match
  token = strscan(SCANNER_REGEXP)
  type, name = TOKENS[token]

  case type
  when :word_pair
    # If the character before word pair delimiter is alphanumeric, do not treat as word pair.
    word_pair = strscan(WORD_REGEXPS[token]) unless /[a-zA-Z0-9]\z/.match?(last_match)

    if word_pair.nil?
      [:text, token, nil]
    elsif token == '__' && word_pair.match?(/\A[a-zA-Z]+__\z/)
      # Special exception: __FILE__, __LINE__, __send__ should be treated as normal text.
      [:text, "#{token}#{word_pair}", nil]
    else
      [:node, nil, { type: WORD_PAIRS[token], children: [word_pair.delete_suffix(token)] }]
    end
  when :open_tag
    [:open, token, name]
  when :close_tag
    [:close, token, name]
  when :code_start
    if (codeblock = strscan(CODEBLOCK_REGEXPS[name], negative_cache: true))
      # Need to unescape `\\` and `\<`.
      # RDoc also unescapes backslash + word separators, but this is not really necessary.
      content = codeblock.delete_suffix("</#{name}>").gsub(/\\(.)/) { '\\<*+_`'.include?($1) ? $1 : $& }
      [:node, nil, { type: :TT, children: content.empty? ? [] : [content] }]
    else
      [:text, token, nil]
    end
  when :standalone_tag
    [:node, nil, { type: STANDALONE_TAGS[name], children: [] }]
  when :tidylink_start
    [:tidylink_open, token, nil]
  when :tidylink_mid
    if @delimiters[:tidylink]
      if (url = read_tidylink_url)
        [:tidylink_close, nil, url]
      else
        [:tidylink_close, token, nil]
      end
    elsif @delimiters[:invalidated_tidylink]
      [:invalidated_tidylink_close, token, nil]
    else
      [:text, token, nil]
    end
  when :escape
    next_char = strscan(/./)
    if next_char.nil?
      # backslash at end of string
      [:text, '\\', nil]
    elsif next_char && ESCAPING_CHARS.include?(next_char)
      # escaped character
      [:text, next_char, nil]
    else
      # If next_char not an escaping character, it is treated as text token with backslash + next_char
      # For example, backslash of `\Ruby` (suppressed crossref) remains.
      [:text, "\\#{next_char}", nil]
    end
  else
    if token.nil?
      [:eof, nil, nil]
    elsif token.match?(/\A[A-Za-z0-9]*\z/) && (url = read_tidylink_url)
      # Simplified tidylink: label[url]
      [:node, nil, { type: :TIDYLINK, children: [token], url: url }]
    else
      [:text, token, nil]
    end
  end
end

# File 'lib/rdoc/markup/inline_parser.rb', line 191

def stack_pop
  delimiter = current[:delimiter]
  @delimiters[delimiter].pop
  @delimiters.delete(delimiter) if @delimiters[delimiter].empty?
  @stack.pop
end

# File 'lib/rdoc/markup/inline_parser.rb', line 200

def stack_push(delimiter, token)
  node = { delimiter: delimiter, token: token, children: [] }
  (@delimiters[delimiter] ||= []) << @stack.size
  @stack << node
end

# File 'lib/rdoc/markup/inline_parser.rb', line 218

def strscan(pattern, negative_cache: false)
  return if negative_cache && @scanner_negative_cache.include?(pattern)

  string = @scanner.scan(pattern)
  @last_match = string if string
  @scanner_negative_cache << pattern if !string && negative_cache
  string
end