Class: YARD::Handlers::Ruby::Legacy::Base Abstract

# File 'lib/yard/handlers/ruby/legacy/base.rb', line 53

def caller_method
  if statement.tokens.first.is_a?(TkIDENTIFIER)
    statement.tokens.first.text
  elsif statement.tokens.first.is_a?(TkDEF)
    extract_method_details.first
  end
end

# File 'lib/yard/handlers/ruby/legacy/base.rb', line 68

def extract_method_details
  if statement.tokens.to_s =~ /^def\s+(#{METHODMATCH})(?:(?:\s+|\s*\()(.*)(?:\)\s*$)?)?/m
    meth = $1
    args = $2
    meth.gsub!(/\s+/, '')
    args = tokval_list(Parser::Ruby::Legacy::TokenList.new(args), :all)
    args.map! {|a| k, v = *a.split('=', 2); [k.strip, (v ? v.strip : nil)] } if args
    meth = $` if meth =~ /(?:#{NSEPQ}|#{CSEPQ})([^#{NSEP}#{CSEPQ}]+)$/
    [meth, args]
  end
end

# File 'lib/yard/handlers/ruby/legacy/base.rb', line 35

def parse_block(opts = {})
  push_state(opts) do
    if statement.block
      blk = Parser::Ruby::Legacy::StatementList.new(statement.block)
      parser.process(blk)
    end
  end
end

# File 'lib/yard/handlers/ruby/legacy/base.rb', line 112

def tokval(token, *accepted_types)
  accepted_types = [TkVal] if accepted_types.empty?
  accepted_types.push(TkNode) if accepted_types.include? TkVal

  if accepted_types.include?(:attr)
    accepted_types.push(TkSTRING, TkSYMBOL)
  end

  if accepted_types.include?(:string)
    accepted_types.push(TkSTRING, TkDSTRING, TkXSTRING, TkDXSTRING)
  end

  if accepted_types.include?(:identifier)
    accepted_types.push(TkIDENTIFIER, TkFID, TkGVAR)
  end

  if accepted_types.include?(:number)
    accepted_types.push(TkFLOAT, TkINTEGER)
  end

  return unless accepted_types.any? {|t| t === token }

  case token
  when TkSTRING, TkDSTRING, TkXSTRING, TkDXSTRING
    token.text[1..-2]
  when TkSYMBOL
    token.text[1..-1].to_sym
  when TkFLOAT
    token.text.to_f
  when TkINTEGER
    token.text.to_i
  when TkREGEXP
    token.text =~ %r{\A/(.+)/([^/])\Z}
    Regexp.new($1, $2)
  when TkTRUE
    true
  when TkFALSE
    false
  when TkNIL
    nil
  else
    token.text
  end
end

# File 'lib/yard/handlers/ruby/legacy/base.rb', line 178

def tokval_list(tokenlist, *accepted_types)
  return [] unless tokenlist
  out = [[]]
  parencount = 0
  beforeparen = 0
  needcomma = false
  seen_comma = true
  tokenlist.each do |token|
    tokval = accepted_types == [:all] ? token.text : tokval(token, *accepted_types)
    parencond = !out.last.empty? && !tokval.nil?
    # puts "#{seen_comma.inspect} #{parencount} #{token.class.class_name} #{out.inspect}"
    case token
    when TkCOMMA
      if parencount == 0
        out << [] unless out.last.empty?
        needcomma = false
        seen_comma = true
      elsif parencond
        out.last << token.text
      end
    when TkLPAREN
      if seen_comma
        beforeparen += 1
      else
        parencount += 1
        out.last << token.text if parencond
      end
    when TkRPAREN
      if beforeparen > 0
        beforeparen -= 1
      else
        out.last << token.text if parencount > 0 && !tokval.nil?
        parencount -= 1
      end
    when TkLBRACE, TkLBRACK, TkDO
      parencount += 1
      out.last << token.text unless tokval.nil?
    when TkRBRACE, TkRBRACK, TkEND
      out.last << token.text unless tokval.nil?
      parencount -= 1
    else
      break if TkKW === token && ![TkTRUE, TkFALSE, TkSUPER, TkSELF, TkNIL].include?(token.class)

      seen_comma = false unless TkWhitespace === token
      if parencount == 0
        next if needcomma
        next if TkWhitespace === token
        if !tokval.nil?
          out.last << tokval
        else
          out.last.clear
          needcomma = true
        end
      elsif parencond
        needcomma = true
        out.last << token.text
      end
    end

    break if beforeparen == 0 && parencount < 0
  end
  # Flatten any single element lists
  out.map {|e| e.empty? ? nil : (e.size == 1 ? e.pop : e.flatten.join) }.compact
end