1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/cmd/tools/vdoc/utils.v
2021-04-02 01:57:09 +03:00

276 lines
7.0 KiB
V

module main
import os
import v.doc
import term
import v.ast
import v.scanner
import v.token
import strings
import v.pref
[inline]
fn slug(title string) string {
return title.replace(' ', '-')
}
fn escape(str string) string {
return str.replace_each(['"', '\\"', '\r\n', '\\n', '\n', '\\n', '\t', '\\t'])
}
fn get_sym_name(dn doc.DocNode) string {
sym_name := if dn.parent_name.len > 0 && dn.parent_name != 'void' {
'($dn.parent_name) $dn.name'
} else {
dn.name
}
return sym_name
}
fn get_node_id(dn doc.DocNode) string {
tag := if dn.parent_name.len > 0 && dn.parent_name != 'void' {
'${dn.parent_name}.$dn.name'
} else {
dn.name
}
return slug(tag)
}
fn is_module_readme(dn doc.DocNode) bool {
if dn.comments.len > 0 && dn.content == 'module $dn.name' {
return true
}
return false
}
fn trim_doc_node_description(description string) string {
mut dn_description := description.replace_each(['\r\n', '\n', '"', '\\"'])
// 80 is enough to fill one line
if dn_description.len > 80 {
dn_description = dn_description[..80]
}
if dn_description.contains('\n') {
dn_description = dn_description.split('\n')[0]
}
// if \ is last character, it ends with \" which leads to a JS error
if dn_description.ends_with('\\') {
dn_description = dn_description.trim_right('\\')
}
return dn_description
}
fn set_output_type_from_str(format string) OutputType {
output_type := match format {
'htm', 'html' { OutputType.html }
'md', 'markdown' { OutputType.markdown }
'json' { OutputType.json }
'stdout' { OutputType.stdout }
else { OutputType.plaintext }
}
return output_type
}
fn get_ignore_paths(path string) ?[]string {
ignore_file_path := os.join_path(path, '.vdocignore')
ignore_content := os.read_file(ignore_file_path) or {
return error_with_code('ignore file not found.', 1)
}
mut res := []string{}
if ignore_content.trim_space().len > 0 {
rules := ignore_content.split_into_lines().map(it.trim_space())
mut final := []string{}
for rule in rules {
if rule.contains('*.') || rule.contains('**') {
println('vdoc: Wildcards in ignore rules are not allowed for now.')
continue
}
final << rule
}
res = final.map(os.join_path(path, it.trim_right('/')))
} else {
mut dirs := os.ls(path) or { return []string{} }
res = dirs.map(os.join_path(path, it)).filter(os.is_dir(it))
}
return res.map(it.replace('/', os.path_separator))
}
fn is_included(path string, ignore_paths []string) bool {
if path.len == 0 {
return true
}
for ignore_path in ignore_paths {
if !path.contains(ignore_path) {
continue
}
return false
}
return true
}
fn get_modules_list(path string, ignore_paths2 []string) []string {
files := os.ls(path) or { return []string{} }
mut ignore_paths := get_ignore_paths(path) or { []string{} }
ignore_paths << ignore_paths2
mut dirs := []string{}
for file in files {
fpath := os.join_path(path, file)
if os.is_dir(fpath) && is_included(fpath, ignore_paths) && !os.is_link(path) {
dirs << get_modules_list(fpath, ignore_paths.filter(it.starts_with(fpath)))
} else if fpath.ends_with('.v') && !fpath.ends_with('_test.v') {
if path in dirs {
continue
}
dirs << path
}
}
dirs.sort()
return dirs
}
fn gen_footer_text(d &doc.Doc, include_timestamp bool) string {
footer_text := 'Powered by vdoc.'
if !include_timestamp {
return footer_text
}
generated_time := d.time_generated
time_str := '$generated_time.day $generated_time.smonth() $generated_time.year $generated_time.hhmmss()'
return '$footer_text Generated on: $time_str'
}
fn color_highlight(code string, tb &ast.Table) string {
builtin := ['bool', 'string', 'i8', 'i16', 'int', 'i64', 'i128', 'byte', 'u16', 'u32', 'u64',
'u128', 'rune', 'f32', 'f64', 'int_literal', 'float_literal', 'byteptr', 'voidptr', 'any']
highlight_code := fn (tok token.Token, typ HighlightTokenTyp) string {
mut lit := ''
match typ {
.unone, .operator, .punctuation {
lit = tok.kind.str()
}
.string {
use_double_quote := tok.lit.contains("'") && !tok.lit.contains('"')
unescaped_val := tok.lit.replace('\\\\', '\x01').replace_each(["\\'", "'", '\\"',
'"',
])
if use_double_quote {
s := unescaped_val.replace_each(['\x01', '\\\\', '"', '\\"'])
lit = term.yellow('"$s"')
} else {
s := unescaped_val.replace_each(['\x01', '\\\\', "'", "\\'"])
lit = term.yellow("'$s'")
}
}
.char {
lit = term.yellow('`$tok.lit`')
}
.keyword {
lit = term.bright_blue(tok.lit)
}
.builtin, .symbol {
lit = term.green(tok.lit)
}
.function {
lit = term.cyan(tok.lit)
}
.number, .module_ {
lit = term.bright_blue(tok.lit)
}
.boolean {
lit = term.bright_magenta(tok.lit)
}
.none_ {
lit = term.red(tok.lit)
}
.prefix {
lit = term.magenta(tok.lit)
}
else {
lit = tok.lit
}
}
return lit
}
mut s := scanner.new_scanner(code, .parse_comments, &pref.Preferences{ is_fmt: true })
mut prev_prev := token.Token{}
mut prev := token.Token{}
mut tok := s.scan()
mut next_tok := s.scan()
mut buf := strings.new_builder(200)
mut i := 0
for i < code.len {
if i == tok.pos {
mut tok_typ := HighlightTokenTyp.unone
match tok.kind {
.name {
if (tok.lit in builtin || tb.known_type(tok.lit))
&& (next_tok.kind != .lpar || prev.kind !in [.key_fn, .rpar]) {
tok_typ = .builtin
} else if
next_tok.kind in [.lcbr, .rpar, .eof, .comma, .pipe, .name, .rcbr, .assign, .key_pub, .key_mut, .pipe, .comma]
&& prev.kind in [.name, .amp, .rsbr, .key_type, .assign, .dot, .question, .rpar, .key_struct, .key_enum, .pipe, .key_interface]
&& (tok.lit[0].ascii_str().is_upper() || prev_prev.lit in ['C', 'JS']) {
tok_typ = .symbol
} else if next_tok.kind in [.lpar, .lt] {
tok_typ = .function
} else if next_tok.kind == .dot {
if tok.lit in ['C', 'JS'] {
tok_typ = .prefix
} else {
if tok.lit[0].ascii_str().is_upper() {
tok_typ = .symbol
} else {
tok_typ = .module_
}
}
} else if tok.lit in ['r', 'c'] && next_tok.kind == .string {
tok_typ = .prefix
} else {
tok_typ = .name
}
}
.comment {
tok_typ = .comment
}
.chartoken {
tok_typ = .char
}
.string {
tok_typ = .string
}
.number {
tok_typ = .number
}
.key_true, .key_false {
tok_typ = .boolean
}
.lpar, .lcbr, .rpar, .rcbr, .lsbr, .rsbr, .semicolon, .colon, .comma, .dot {
tok_typ = .punctuation
}
.key_none {
tok_typ = .none_
}
else {
if token.is_key(tok.lit) || token.is_decl(tok.kind) {
tok_typ = .keyword
} else if tok.kind == .decl_assign || tok.kind.is_assign() || tok.is_unary()
|| tok.kind.is_relational() || tok.kind.is_infix() {
tok_typ = .operator
}
}
}
buf.write_string(highlight_code(tok, tok_typ))
if prev_prev.kind == .eof || prev.kind == .eof || next_tok.kind == .eof {
break
}
prev_prev = prev
prev = tok
i = tok.pos + tok.len
tok = next_tok
next_tok = s.scan()
} else {
buf.write_b(code[i])
i++
}
}
return buf.str()
}