2020-06-02 13:10:01 +03:00
|
|
|
module main
|
|
|
|
|
|
|
|
|
|
import markdown
|
|
|
|
|
import net
|
|
|
|
|
import net.urllib
|
|
|
|
|
import os
|
|
|
|
|
import os.cmdline
|
2020-06-06 15:31:26 +03:00
|
|
|
import time
|
2020-06-02 13:10:01 +03:00
|
|
|
import strings
|
2020-09-23 21:50:51 +03:00
|
|
|
import sync
|
|
|
|
|
import runtime
|
2020-06-02 13:10:01 +03:00
|
|
|
import v.doc
|
2020-06-06 08:56:17 +03:00
|
|
|
import v.scanner
|
|
|
|
|
import v.table
|
|
|
|
|
import v.token
|
2020-06-02 13:10:01 +03:00
|
|
|
import v.vmod
|
2020-07-11 13:04:05 +03:00
|
|
|
import v.pref
|
2020-10-21 11:26:33 +03:00
|
|
|
import json
|
2020-06-02 13:10:01 +03:00
|
|
|
|
2020-06-06 08:56:17 +03:00
|
|
|
enum HighlightTokenTyp {
|
|
|
|
|
unone
|
|
|
|
|
boolean
|
|
|
|
|
builtin
|
|
|
|
|
char
|
|
|
|
|
comment
|
|
|
|
|
function
|
|
|
|
|
keyword
|
|
|
|
|
name
|
|
|
|
|
number
|
|
|
|
|
operator
|
|
|
|
|
punctuation
|
|
|
|
|
string
|
|
|
|
|
symbol
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-05 00:50:59 +03:00
|
|
|
const (
|
2020-09-21 17:40:39 +03:00
|
|
|
css_js_assets = ['doc.css', 'normalize.css', 'doc.js']
|
2020-06-05 10:59:26 +03:00
|
|
|
allowed_formats = ['md', 'markdown', 'json', 'text', 'stdout', 'html', 'htm']
|
2020-06-05 15:22:50 +03:00
|
|
|
exe_path = os.executable()
|
|
|
|
|
exe_dir = os.dir(exe_path)
|
|
|
|
|
res_path = os.join_path(exe_dir, 'vdoc-resources')
|
2020-10-01 02:30:22 +03:00
|
|
|
vexe_path = os.dir(@VEXE)
|
2020-06-19 11:36:45 +03:00
|
|
|
html_content = '
|
|
|
|
|
<!DOCTYPE html>
|
|
|
|
|
<html lang="en">
|
|
|
|
|
<head>
|
|
|
|
|
<meta charset="UTF-8">
|
|
|
|
|
<meta http-equiv="x-ua-compatible" content="IE=edge" />
|
|
|
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
2020-07-11 13:04:05 +03:00
|
|
|
<title>{{ title }} | vdoc</title>
|
2020-06-19 11:36:45 +03:00
|
|
|
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700&display=swap" rel="stylesheet">
|
|
|
|
|
{{ head_assets }}
|
|
|
|
|
</head>
|
|
|
|
|
<body>
|
|
|
|
|
<div id="page">
|
|
|
|
|
<header class="doc-nav hidden">
|
|
|
|
|
<div class="heading-container">
|
|
|
|
|
<div class="heading">
|
|
|
|
|
<input type="text" id="search" placeholder="Search...">
|
|
|
|
|
<div class="module">{{ head_name }}</div>
|
|
|
|
|
<div class="toggle-version-container">
|
|
|
|
|
<span>{{ version }}</span>
|
|
|
|
|
<div id="dark-mode-toggle" role="switch" aria-checked="false" aria-label="Toggle dark mode">{{ light_icon }}{{ dark_icon }}</div>
|
|
|
|
|
</div>
|
|
|
|
|
{{ menu_icon }}
|
|
|
|
|
</div>
|
|
|
|
|
</div>
|
|
|
|
|
<nav class="content hidden">
|
|
|
|
|
<ul>
|
|
|
|
|
{{ toc_links }}
|
|
|
|
|
</ul>
|
|
|
|
|
</nav>
|
|
|
|
|
</header>
|
|
|
|
|
<div class="doc-container">
|
|
|
|
|
<div class="doc-content">
|
|
|
|
|
{{ contents }}
|
|
|
|
|
<div class="footer">
|
|
|
|
|
{{ footer_content }}
|
|
|
|
|
</div>
|
|
|
|
|
</div>
|
|
|
|
|
{{ right_content }}
|
|
|
|
|
</div>
|
|
|
|
|
</div>
|
|
|
|
|
{{ footer_assets }}
|
|
|
|
|
</body>
|
|
|
|
|
</html>
|
|
|
|
|
'
|
2020-06-05 00:50:59 +03:00
|
|
|
)
|
|
|
|
|
|
2020-06-02 13:10:01 +03:00
|
|
|
enum OutputType {
|
2020-06-05 10:59:26 +03:00
|
|
|
unset
|
2020-06-02 13:10:01 +03:00
|
|
|
html
|
|
|
|
|
markdown
|
|
|
|
|
json
|
|
|
|
|
plaintext
|
|
|
|
|
stdout
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct DocConfig {
|
|
|
|
|
mut:
|
2020-09-21 17:40:39 +03:00
|
|
|
is_local bool
|
|
|
|
|
local_filename string
|
|
|
|
|
local_pos int
|
2020-06-05 15:22:50 +03:00
|
|
|
pub_only bool = true
|
2020-09-21 17:40:39 +03:00
|
|
|
show_loc bool // for plaintext
|
|
|
|
|
serve_http bool // for html
|
2020-09-09 16:34:41 +03:00
|
|
|
is_multi bool
|
2020-10-29 19:21:37 +03:00
|
|
|
is_vlib bool
|
2020-09-09 16:34:41 +03:00
|
|
|
is_verbose bool
|
|
|
|
|
include_readme bool
|
|
|
|
|
open_docs bool
|
2020-09-21 17:40:39 +03:00
|
|
|
server_port int = 8046
|
2020-09-09 16:34:41 +03:00
|
|
|
inline_assets bool
|
2020-10-19 22:30:37 +03:00
|
|
|
no_timestamp bool
|
2020-06-05 15:22:50 +03:00
|
|
|
output_path string
|
|
|
|
|
input_path string
|
2020-09-21 17:40:39 +03:00
|
|
|
symbol_name string
|
2020-06-05 15:22:50 +03:00
|
|
|
output_type OutputType = .unset
|
|
|
|
|
docs []doc.Doc
|
|
|
|
|
manifest vmod.Manifest
|
2020-09-23 21:50:51 +03:00
|
|
|
assets map[string]string
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct ParallelDoc {
|
|
|
|
|
d doc.Doc
|
|
|
|
|
i int
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
|
2020-10-21 11:26:33 +03:00
|
|
|
[inline]
|
2020-06-02 13:10:01 +03:00
|
|
|
fn slug(title string) string {
|
|
|
|
|
return title.replace(' ', '-')
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-21 11:26:33 +03:00
|
|
|
[inline]
|
2020-06-02 13:10:01 +03:00
|
|
|
fn open_url(url string) {
|
|
|
|
|
$if windows {
|
|
|
|
|
os.system('start $url')
|
|
|
|
|
}
|
|
|
|
|
$if macos {
|
|
|
|
|
os.system('open $url')
|
|
|
|
|
}
|
|
|
|
|
$if linux {
|
|
|
|
|
os.system('xdg-open $url')
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn (mut cfg DocConfig) serve_html() {
|
2020-09-23 21:50:51 +03:00
|
|
|
cfg.render_static()
|
2020-06-05 10:59:26 +03:00
|
|
|
docs := cfg.render()
|
2020-07-11 13:04:05 +03:00
|
|
|
dkeys := docs.keys()
|
2020-06-20 19:33:44 +03:00
|
|
|
if dkeys.len < 1 {
|
|
|
|
|
eprintln('no documentation created, the module has no `pub` functions')
|
|
|
|
|
exit(1)
|
|
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
def_name := docs.keys()[0]
|
2020-06-20 19:33:44 +03:00
|
|
|
server_url := 'http://localhost:' + cfg.server_port.str()
|
2020-06-07 13:27:42 +03:00
|
|
|
server := net.listen(cfg.server_port) or {
|
2020-06-02 13:10:01 +03:00
|
|
|
panic(err)
|
|
|
|
|
}
|
2020-06-07 13:27:42 +03:00
|
|
|
println('Serving docs on: $server_url')
|
|
|
|
|
if cfg.open_docs {
|
|
|
|
|
open_url(server_url)
|
|
|
|
|
}
|
2020-06-19 11:36:45 +03:00
|
|
|
content_type := match cfg.output_type {
|
|
|
|
|
.html { 'text/html' }
|
|
|
|
|
.markdown { 'text/markdown' }
|
|
|
|
|
.json { 'application/json' }
|
|
|
|
|
else { 'text/plain' }
|
|
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
server_context := VdocHttpServerContext{
|
2020-06-21 17:41:43 +03:00
|
|
|
docs: docs
|
|
|
|
|
content_type: content_type
|
|
|
|
|
default_filename: def_name
|
|
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
for {
|
2020-06-30 15:19:22 +03:00
|
|
|
mut con := server.accept() or {
|
2020-06-02 13:10:01 +03:00
|
|
|
server.close() or { }
|
|
|
|
|
panic(err)
|
|
|
|
|
}
|
2020-06-21 17:41:43 +03:00
|
|
|
handle_http_connection(mut con, server_context)
|
|
|
|
|
con.close() or {
|
|
|
|
|
eprintln('error closing the connection: $err')
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-06-21 17:41:43 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct VdocHttpServerContext {
|
2020-09-21 17:40:39 +03:00
|
|
|
docs map[string]string
|
|
|
|
|
content_type string
|
2020-06-21 17:41:43 +03:00
|
|
|
default_filename string
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn handle_http_connection(mut con net.Socket, ctx &VdocHttpServerContext) {
|
|
|
|
|
s := con.read_line()
|
|
|
|
|
first_line := s.all_before('\r\n')
|
|
|
|
|
if first_line.len == 0 {
|
|
|
|
|
send_http_response(mut con, 501, ctx.content_type, 'bad request')
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
request_parts := first_line.split(' ')
|
|
|
|
|
if request_parts.len != 3 {
|
|
|
|
|
send_http_response(mut con, 501, ctx.content_type, 'bad request')
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
urlpath := request_parts[1]
|
|
|
|
|
filename := if urlpath == '/' { ctx.default_filename.trim_left('/') } else { urlpath.trim_left('/') }
|
|
|
|
|
if ctx.docs[filename].len == 0 {
|
|
|
|
|
send_http_response(mut con, 404, ctx.content_type, 'file not found')
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
send_http_response(mut con, 200, ctx.content_type, ctx.docs[filename])
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-15 16:17:52 +03:00
|
|
|
fn send_http_response(mut con net.Socket, http_code int, content_type string, html string) {
|
2020-06-21 17:41:43 +03:00
|
|
|
content_length := html.len.str()
|
|
|
|
|
shttp_code := http_code.str()
|
|
|
|
|
mut http_response := strings.new_builder(20000)
|
|
|
|
|
http_response.write('HTTP/1.1 ')
|
|
|
|
|
http_response.write(shttp_code)
|
|
|
|
|
http_response.write(' OK\r\n')
|
|
|
|
|
http_response.write('Server: VDoc\r\n')
|
|
|
|
|
http_response.write('Content-Type: ')
|
|
|
|
|
http_response.write(content_type)
|
|
|
|
|
http_response.write('\r\n')
|
|
|
|
|
http_response.write('Content-Length: ')
|
|
|
|
|
http_response.write(content_length)
|
|
|
|
|
http_response.write('\r\n')
|
|
|
|
|
http_response.write('Connection: close\r\n')
|
|
|
|
|
http_response.write('\r\n')
|
|
|
|
|
http_response.write(html)
|
|
|
|
|
sresponse := http_response.str()
|
|
|
|
|
con.send_string(sresponse) or {
|
|
|
|
|
eprintln('error sending http response: $err')
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-15 16:17:52 +03:00
|
|
|
fn get_src_link(repo_url string, file_name string, line_nr int) string {
|
2020-06-02 13:10:01 +03:00
|
|
|
mut url := urllib.parse(repo_url) or {
|
|
|
|
|
return ''
|
|
|
|
|
}
|
|
|
|
|
if url.path.len <= 1 || file_name.len == 0 {
|
|
|
|
|
return ''
|
|
|
|
|
}
|
|
|
|
|
url.path = url.path.trim_right('/') + match url.host {
|
|
|
|
|
'github.com' { '/blob/master/$file_name' }
|
|
|
|
|
'gitlab.com' { '/-/blob/master/$file_name' }
|
|
|
|
|
'git.sir.ht' { '/tree/master/$file_name' }
|
|
|
|
|
else { '' }
|
|
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
if url.path == '/' {
|
|
|
|
|
return ''
|
|
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
url.fragment = 'L$line_nr'
|
|
|
|
|
return url.str()
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-08 11:28:46 +03:00
|
|
|
fn js_compress(str string) string {
|
|
|
|
|
mut js := strings.new_builder(200)
|
|
|
|
|
lines := str.split_into_lines()
|
2020-09-21 17:40:39 +03:00
|
|
|
rules := [') {', ' = ', ', ', '{ ', ' }', ' (', '; ', ' + ', ' < ', ' - ', ' || ', ' var',
|
|
|
|
|
': ', ' >= ', ' && ', ' else if', ' === ', ' !== ', ' else ']
|
|
|
|
|
clean := ['){', '=', ',', '{', '}', '(', ';', '+', '<', '-', '||', 'var', ':', '>=', '&&',
|
|
|
|
|
'else if', '===', '!==', 'else']
|
2020-06-08 11:28:46 +03:00
|
|
|
for line in lines {
|
|
|
|
|
mut trimmed := line.trim_space()
|
2020-09-21 17:40:39 +03:00
|
|
|
if trimmed.starts_with('//') || (trimmed.starts_with('/*') && trimmed.ends_with('*/')) {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
for i in 0 .. rules.len - 1 {
|
2020-06-08 11:28:46 +03:00
|
|
|
trimmed = trimmed.replace(rules[i], clean[i])
|
|
|
|
|
}
|
|
|
|
|
js.write(trimmed)
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
js_str := js.str()
|
|
|
|
|
js.free()
|
|
|
|
|
return js_str
|
2020-06-08 11:28:46 +03:00
|
|
|
}
|
|
|
|
|
|
2020-06-02 13:10:01 +03:00
|
|
|
fn escape(str string) string {
|
2020-09-21 17:40:39 +03:00
|
|
|
return str.replace_each(['"', '\\"', '\r\n', '\\n', '\n', '\\n', '\t', '\\t'])
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn (cfg DocConfig) gen_json(idx int) string {
|
|
|
|
|
dcs := cfg.docs[idx]
|
|
|
|
|
mut jw := strings.new_builder(200)
|
2020-10-21 11:26:33 +03:00
|
|
|
jw.write('{"module_name":"$dcs.head.name","description":"${escape(dcs.head.comment)}","contents":')
|
|
|
|
|
jw.write(json.encode(dcs.contents.keys().map(dcs.contents[it])))
|
|
|
|
|
jw.write(',"generator":"vdoc","time_generated":"$dcs.time_generated.str()"}')
|
2020-06-02 13:10:01 +03:00
|
|
|
return jw.str()
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-06 08:56:17 +03:00
|
|
|
fn html_highlight(code string, tb &table.Table) string {
|
2020-09-21 17:40:39 +03:00
|
|
|
builtin := ['bool', 'string', 'i8', 'i16', 'int', 'i64', 'i128', 'byte', 'u16', 'u32', 'u64',
|
|
|
|
|
'u128', 'rune', 'f32', 'f64', 'any_int', 'any_float', 'byteptr', 'voidptr', 'any']
|
2020-06-06 08:56:17 +03:00
|
|
|
highlight_code := fn (tok token.Token, typ HighlightTokenTyp) string {
|
2020-07-11 13:04:05 +03:00
|
|
|
lit := if typ in [.unone, .operator, .punctuation] {
|
|
|
|
|
tok.kind.str()
|
|
|
|
|
} else if typ == .string {
|
2020-06-08 11:28:46 +03:00
|
|
|
"'$tok.lit'"
|
|
|
|
|
} else if typ == .char {
|
|
|
|
|
'`$tok.lit`'
|
2020-09-21 17:40:39 +03:00
|
|
|
} else {
|
|
|
|
|
tok.lit
|
|
|
|
|
}
|
|
|
|
|
return if typ in [.unone, .name] {
|
|
|
|
|
lit
|
|
|
|
|
} else {
|
|
|
|
|
'<span class="token $typ">$lit</span>'
|
|
|
|
|
}
|
2020-06-06 08:56:17 +03:00
|
|
|
}
|
2020-07-24 12:30:38 +03:00
|
|
|
mut s := scanner.new_scanner(code, .parse_comments, &pref.Preferences{})
|
2020-06-06 08:56:17 +03:00
|
|
|
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 {
|
2020-06-08 11:28:46 +03:00
|
|
|
if tok.lit in builtin || tb.known_type(tok.lit) {
|
2020-06-06 08:56:17 +03:00
|
|
|
tok_typ = .builtin
|
2020-06-06 15:31:26 +03:00
|
|
|
} else if next_tok.kind == .lcbr {
|
2020-06-06 08:56:17 +03:00
|
|
|
tok_typ = .symbol
|
2020-06-06 15:31:26 +03:00
|
|
|
} else if next_tok.kind == .lpar {
|
|
|
|
|
tok_typ = .function
|
2020-06-06 08:56:17 +03:00
|
|
|
} else {
|
|
|
|
|
tok_typ = .name
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
.comment {
|
|
|
|
|
tok_typ = .comment
|
|
|
|
|
}
|
|
|
|
|
.chartoken {
|
|
|
|
|
tok_typ = .char
|
|
|
|
|
}
|
|
|
|
|
.string {
|
|
|
|
|
tok_typ = .string
|
|
|
|
|
}
|
|
|
|
|
.number {
|
|
|
|
|
tok_typ = .number
|
|
|
|
|
}
|
2020-06-06 11:43:50 +03:00
|
|
|
.key_true, .key_false {
|
2020-06-06 08:56:17 +03:00
|
|
|
tok_typ = .boolean
|
|
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
.lpar, .lcbr, .rpar, .rcbr, .lsbr, .rsbr, .semicolon, .colon, .comma, .dot {
|
2020-06-06 11:43:50 +03:00
|
|
|
tok_typ = .punctuation
|
|
|
|
|
}
|
2020-06-06 08:56:17 +03:00
|
|
|
else {
|
|
|
|
|
if token.is_key(tok.lit) || token.is_decl(tok.kind) {
|
|
|
|
|
tok_typ = .keyword
|
2020-09-21 17:40:39 +03:00
|
|
|
} else if tok.kind == .decl_assign || tok.kind.is_assign() || tok.is_unary() ||
|
|
|
|
|
tok.kind.is_relational() || tok.kind.is_infix() {
|
2020-06-06 08:56:17 +03:00
|
|
|
tok_typ = .operator
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
buf.write(highlight_code(tok, tok_typ))
|
|
|
|
|
if next_tok.kind != .eof {
|
|
|
|
|
i = tok.pos + tok.len
|
|
|
|
|
tok = next_tok
|
|
|
|
|
next_tok = s.scan()
|
|
|
|
|
} else {
|
|
|
|
|
break
|
2020-06-05 00:50:59 +03:00
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
} else {
|
2020-06-06 08:56:17 +03:00
|
|
|
buf.write_b(code[i])
|
|
|
|
|
i++
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
}
|
2020-06-06 08:56:17 +03:00
|
|
|
return buf.str()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn doc_node_html(dd doc.DocNode, link string, head bool, tb &table.Table) string {
|
|
|
|
|
mut dnw := strings.new_builder(200)
|
|
|
|
|
link_svg := '<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"/></svg>'
|
|
|
|
|
head_tag := if head { 'h1' } else { 'h2' }
|
|
|
|
|
md_content := markdown.to_html(dd.comment)
|
|
|
|
|
hlighted_code := html_highlight(dd.content, tb)
|
2020-10-21 11:26:33 +03:00
|
|
|
node_class := if dd.kind == .const_group { ' const' } else { '' }
|
2020-10-21 14:36:16 +03:00
|
|
|
sym_name := if dd.parent_name.len > 0 && dd.parent_name != 'void' { dd.parent_name + '.' +
|
|
|
|
|
dd.name } else { dd.name }
|
2020-06-06 15:31:26 +03:00
|
|
|
node_id := slug(sym_name)
|
2020-06-07 13:27:42 +03:00
|
|
|
hash_link := if !head { ' <a href="#$node_id">#</a>' } else { '' }
|
2020-06-29 12:03:09 +03:00
|
|
|
dnw.writeln('<section id="$node_id" class="doc-node$node_class">')
|
2020-10-21 11:26:33 +03:00
|
|
|
if dd.name.len > 0 {
|
2020-06-07 02:23:56 +03:00
|
|
|
dnw.write('<div class="title"><$head_tag>$sym_name$hash_link</$head_tag>')
|
2020-06-06 08:56:17 +03:00
|
|
|
if link.len != 0 {
|
2020-06-06 11:43:50 +03:00
|
|
|
dnw.write('<a class="link" rel="noreferrer" target="_blank" href="$link">$link_svg</a>')
|
2020-06-06 08:56:17 +03:00
|
|
|
}
|
|
|
|
|
dnw.write('</div>')
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
if !head && dd.content.len > 0 {
|
2020-06-08 14:11:55 +03:00
|
|
|
dnw.writeln('<pre class="signature"><code>$hlighted_code</code></pre>')
|
2020-06-06 08:56:17 +03:00
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
dnw.writeln('$md_content\n</section>')
|
|
|
|
|
dnw_str := dnw.str()
|
|
|
|
|
defer {
|
|
|
|
|
dnw.free()
|
|
|
|
|
}
|
|
|
|
|
return dnw_str
|
2020-06-06 08:56:17 +03:00
|
|
|
}
|
|
|
|
|
|
2020-06-19 11:36:45 +03:00
|
|
|
fn (cfg DocConfig) readme_idx() int {
|
|
|
|
|
for i, dc in cfg.docs {
|
2020-09-21 17:40:39 +03:00
|
|
|
if dc.head.name != 'README' {
|
|
|
|
|
continue
|
|
|
|
|
}
|
2020-06-19 11:36:45 +03:00
|
|
|
return i
|
|
|
|
|
}
|
|
|
|
|
return -1
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-24 12:30:38 +03:00
|
|
|
fn write_toc(cn doc.DocNode, nodes []doc.DocNode, mut toc strings.Builder) {
|
2020-10-29 19:21:37 +03:00
|
|
|
toc_slug := if cn.name.len == 0 || cn.content.len == 0 { '' } else { slug(cn.name) }
|
2020-09-21 17:40:39 +03:00
|
|
|
toc.write('<li class="open"><a href="#$toc_slug">$cn.name</a>')
|
2020-06-19 11:36:45 +03:00
|
|
|
if cn.name != 'Constants' {
|
2020-06-08 11:28:46 +03:00
|
|
|
toc.writeln(' <ul>')
|
2020-10-21 11:26:33 +03:00
|
|
|
for child in cn.children {
|
2020-06-08 11:28:46 +03:00
|
|
|
cname := cn.name + '.' + child.name
|
2020-09-21 17:40:39 +03:00
|
|
|
toc.writeln('<li><a href="#${slug(cname)}">$child.name</a></li>')
|
2020-06-08 11:28:46 +03:00
|
|
|
}
|
|
|
|
|
toc.writeln('</ul>')
|
|
|
|
|
}
|
|
|
|
|
toc.writeln('</li>')
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-24 12:30:38 +03:00
|
|
|
fn (cfg DocConfig) write_content(cn &doc.DocNode, dcs &doc.Doc, mut hw strings.Builder) {
|
2020-10-01 02:30:22 +03:00
|
|
|
base_dir := os.dir(os.real_path(cfg.input_path))
|
2020-06-19 11:36:45 +03:00
|
|
|
file_path_name := if cfg.is_multi { cn.file_path.replace('$base_dir/', '') } else { os.file_name(cn.file_path) }
|
2020-06-08 11:28:46 +03:00
|
|
|
src_link := get_src_link(cfg.manifest.repo_url, file_path_name, cn.pos.line)
|
2020-10-21 11:26:33 +03:00
|
|
|
if cn.content.len != 0 || (cn.name == 'Constants') {
|
2020-06-19 11:36:45 +03:00
|
|
|
hw.write(doc_node_html(cn, src_link, false, dcs.table))
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
for child in cn.children {
|
2020-06-19 11:36:45 +03:00
|
|
|
child_file_path_name := child.file_path.replace('$base_dir/', '')
|
|
|
|
|
child_src_link := get_src_link(cfg.manifest.repo_url, child_file_path_name, child.pos.line)
|
|
|
|
|
hw.write(doc_node_html(child, child_src_link, false, dcs.table))
|
2020-06-08 11:28:46 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-06 08:56:17 +03:00
|
|
|
fn (cfg DocConfig) gen_html(idx int) string {
|
2020-10-21 11:26:33 +03:00
|
|
|
mut symbols_toc := strings.new_builder(200)
|
|
|
|
|
mut modules_toc := strings.new_builder(200)
|
2020-06-19 11:36:45 +03:00
|
|
|
mut contents := strings.new_builder(200)
|
2020-10-21 11:26:33 +03:00
|
|
|
dcs := cfg.docs[idx]
|
|
|
|
|
dcs_contents := dcs.contents.arr()
|
2020-06-02 13:10:01 +03:00
|
|
|
// generate toc first
|
2020-06-19 11:36:45 +03:00
|
|
|
contents.writeln(doc_node_html(dcs.head, '', true, dcs.table))
|
2020-10-21 11:26:33 +03:00
|
|
|
for cn in dcs_contents {
|
2020-09-27 16:58:36 +03:00
|
|
|
cfg.write_content(&cn, &dcs, mut contents)
|
2020-10-21 11:26:33 +03:00
|
|
|
write_toc(cn, dcs_contents, mut symbols_toc)
|
2020-09-21 17:40:39 +03:00
|
|
|
} // write head
|
2020-06-02 13:10:01 +03:00
|
|
|
// write css
|
2020-06-19 11:36:45 +03:00
|
|
|
version := if cfg.manifest.version.len != 0 { cfg.manifest.version } else { '' }
|
2020-09-21 17:40:39 +03:00
|
|
|
header_name := if cfg.is_multi && cfg.docs.len > 1 { os.file_name(os.real_path(cfg.input_path)) } else { dcs.head.name }
|
2020-06-05 00:50:59 +03:00
|
|
|
// write nav1
|
2020-06-19 11:36:45 +03:00
|
|
|
if cfg.is_multi || cfg.docs.len > 1 {
|
2020-06-02 13:10:01 +03:00
|
|
|
mut submod_prefix := ''
|
2020-06-29 12:03:09 +03:00
|
|
|
for i, doc in cfg.docs {
|
2020-09-21 17:40:39 +03:00
|
|
|
if i - 1 >= 0 && doc.head.name.starts_with(submod_prefix + '.') {
|
2020-06-02 13:10:01 +03:00
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
names := doc.head.name.split('.')
|
|
|
|
|
submod_prefix = if names.len > 1 { names[0] } else { doc.head.name }
|
2020-10-29 19:21:37 +03:00
|
|
|
mut href_name := './${doc.head.name}.html'
|
|
|
|
|
if (cfg.is_vlib && doc.head.name == 'builtin' && !cfg.include_readme) ||
|
2020-09-21 17:40:39 +03:00
|
|
|
doc.head.name == 'README' {
|
2020-10-29 19:21:37 +03:00
|
|
|
href_name = './index.html'
|
2020-06-02 13:10:01 +03:00
|
|
|
} else if submod_prefix !in cfg.docs.map(it.head.name) {
|
2020-10-29 19:21:37 +03:00
|
|
|
href_name = '#'
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
submodules := cfg.docs.filter(it.head.name.starts_with(submod_prefix + '.'))
|
2020-09-23 21:50:51 +03:00
|
|
|
dropdown := if submodules.len > 0 { cfg.assets['arrow_icon'] } else { '' }
|
2020-06-05 00:50:59 +03:00
|
|
|
active_class := if doc.head.name == dcs.head.name { ' active' } else { '' }
|
2020-10-21 11:26:33 +03:00
|
|
|
modules_toc.write('<li class="open$active_class"><div class="menu-row">$dropdown<a href="$href_name">$submod_prefix</a></div>')
|
2020-06-02 13:10:01 +03:00
|
|
|
for j, cdoc in submodules {
|
|
|
|
|
if j == 0 {
|
2020-10-21 11:26:33 +03:00
|
|
|
modules_toc.write('<ul>')
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
submod_name := cdoc.head.name.all_after(submod_prefix + '.')
|
2020-06-05 00:50:59 +03:00
|
|
|
sub_selected_classes := if cdoc.head.name == dcs.head.name { ' class="active"' } else { '' }
|
2020-10-21 11:26:33 +03:00
|
|
|
modules_toc.write('<li$sub_selected_classes><a href="./${cdoc.head.name}.html">$submod_name</a></li>')
|
2020-06-05 00:50:59 +03:00
|
|
|
if j == submodules.len - 1 {
|
2020-10-21 11:26:33 +03:00
|
|
|
modules_toc.write('</ul>')
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
modules_toc.write('</li>')
|
2020-06-19 11:36:45 +03:00
|
|
|
}
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
modules_toc_str := modules_toc.str()
|
|
|
|
|
symbols_toc_str := symbols_toc.str()
|
|
|
|
|
modules_toc.free()
|
|
|
|
|
symbols_toc.free()
|
2020-09-21 17:40:39 +03:00
|
|
|
return html_content.replace('{{ title }}', dcs.head.name).replace('{{ head_name }}',
|
2020-09-23 21:50:51 +03:00
|
|
|
header_name).replace('{{ version }}', version).replace('{{ light_icon }}', cfg.assets['light_icon']).replace('{{ dark_icon }}',
|
2020-10-15 16:17:52 +03:00
|
|
|
cfg.assets['dark_icon']).replace('{{ menu_icon }}', cfg.assets['menu_icon']).replace('{{ head_assets }}',
|
|
|
|
|
if cfg.inline_assets {
|
|
|
|
|
'\n <style>' + cfg.assets['doc_css'] + '</style>\n <style>' + cfg.assets['normalize_css'] +
|
|
|
|
|
'</style>'
|
2020-09-21 17:40:39 +03:00
|
|
|
} else {
|
2020-10-15 16:17:52 +03:00
|
|
|
'\n <link rel="stylesheet" href="' + cfg.assets['doc_css'] + '" />\n <link rel="stylesheet" href="' +
|
|
|
|
|
cfg.assets['normalize_css'] + '" />'
|
2020-09-21 17:40:39 +03:00
|
|
|
}).replace('{{ toc_links }}', if cfg.is_multi || cfg.docs.len > 1 {
|
2020-10-21 11:26:33 +03:00
|
|
|
modules_toc_str
|
2020-09-21 17:40:39 +03:00
|
|
|
} else {
|
2020-10-21 11:26:33 +03:00
|
|
|
symbols_toc_str
|
2020-09-21 17:40:39 +03:00
|
|
|
}).replace('{{ contents }}', contents.str()).replace('{{ right_content }}', if cfg.is_multi &&
|
|
|
|
|
cfg.docs.len > 1 && dcs.head.name != 'README' {
|
2020-10-21 11:26:33 +03:00
|
|
|
'<div class="doc-toc"><ul>' + symbols_toc_str + '</ul></div>'
|
2020-09-21 17:40:39 +03:00
|
|
|
} else {
|
|
|
|
|
''
|
2020-10-19 22:30:37 +03:00
|
|
|
}).replace('{{ footer_content }}', cfg.gen_footer_text(idx)).replace('{{ footer_assets }}',
|
2020-09-21 17:40:39 +03:00
|
|
|
if cfg.inline_assets {
|
2020-10-15 16:17:52 +03:00
|
|
|
'<script>' + cfg.assets['doc_js'] + '</script>'
|
2020-09-21 17:40:39 +03:00
|
|
|
} else {
|
2020-10-15 16:17:52 +03:00
|
|
|
'<script src="' + cfg.assets['doc_js'] + '"></script>'
|
2020-09-21 17:40:39 +03:00
|
|
|
})
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn (cfg DocConfig) gen_plaintext(idx int) string {
|
|
|
|
|
dcs := cfg.docs[idx]
|
|
|
|
|
mut pw := strings.new_builder(200)
|
2020-09-21 17:40:39 +03:00
|
|
|
pw.writeln('$dcs.head.content\n')
|
2020-06-29 12:03:09 +03:00
|
|
|
if dcs.head.comment.trim_space().len > 0 && !cfg.pub_only {
|
|
|
|
|
pw.writeln(dcs.head.comment.split_into_lines().map(' ' + it).join('\n'))
|
2020-06-08 09:22:10 +03:00
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
for _, cn in dcs.contents {
|
2020-06-02 13:10:01 +03:00
|
|
|
pw.writeln(cn.content)
|
2020-06-29 12:03:09 +03:00
|
|
|
if cn.comment.len > 0 && !cfg.pub_only {
|
|
|
|
|
pw.writeln(cn.comment.trim_space().split_into_lines().map(' ' + it).join('\n'))
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
if cfg.show_loc {
|
2020-10-21 11:26:33 +03:00
|
|
|
pw.writeln('Location: $cn.file_path:$cn.pos.line\n')
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return pw.str()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn (cfg DocConfig) gen_markdown(idx int, with_toc bool) string {
|
|
|
|
|
dcs := cfg.docs[idx]
|
|
|
|
|
mut hw := strings.new_builder(200)
|
|
|
|
|
mut cw := strings.new_builder(200)
|
2020-09-21 17:40:39 +03:00
|
|
|
hw.writeln('# $dcs.head.content\n$dcs.head.comment\n')
|
2020-06-02 13:10:01 +03:00
|
|
|
if with_toc {
|
|
|
|
|
hw.writeln('## Contents')
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
for _, cn in dcs.contents {
|
2020-06-07 13:27:42 +03:00
|
|
|
name := cn.name.all_after(dcs.head.name + '.')
|
2020-06-02 13:10:01 +03:00
|
|
|
if with_toc {
|
|
|
|
|
hw.writeln('- [#$name](${slug(name)})')
|
|
|
|
|
}
|
|
|
|
|
cw.writeln('## $name')
|
2020-09-21 17:40:39 +03:00
|
|
|
cw.writeln('```v\n$cn.content\n```$cn.comment\n')
|
2020-06-02 13:10:01 +03:00
|
|
|
cw.writeln('[\[Return to contents\]](#Contents)\n')
|
|
|
|
|
}
|
2020-10-19 22:30:37 +03:00
|
|
|
footer_text := cfg.gen_footer_text(idx)
|
|
|
|
|
cw.writeln('#### $footer_text')
|
2020-06-02 13:10:01 +03:00
|
|
|
return hw.str() + '\n' + cw.str()
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-19 22:30:37 +03:00
|
|
|
fn (cfg DocConfig) gen_footer_text(idx int) string {
|
|
|
|
|
current_doc := cfg.docs[idx]
|
|
|
|
|
footer_text := 'Powered by vdoc.'
|
|
|
|
|
if cfg.no_timestamp {
|
|
|
|
|
return footer_text
|
|
|
|
|
}
|
|
|
|
|
generated_time := current_doc.time_generated
|
|
|
|
|
time_str := '$generated_time.day $generated_time.smonth() $generated_time.year $generated_time.hhmmss()'
|
|
|
|
|
return '$footer_text Generated on: $time_str'
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-23 21:50:51 +03:00
|
|
|
fn (cfg DocConfig) render_doc(doc doc.Doc, i int) (string, string) {
|
|
|
|
|
// since builtin is generated first, ignore it
|
2020-10-29 19:21:37 +03:00
|
|
|
mut name := doc.head.name
|
|
|
|
|
if (cfg.is_vlib && doc.head.name == 'builtin' && !cfg.include_readme) ||
|
2020-09-23 21:50:51 +03:00
|
|
|
doc.head.name == 'README' {
|
2020-10-29 19:21:37 +03:00
|
|
|
name = 'index'
|
2020-09-23 21:50:51 +03:00
|
|
|
} else if !cfg.is_multi && !os.is_dir(cfg.output_path) {
|
2020-10-29 19:21:37 +03:00
|
|
|
name = os.file_name(cfg.output_path)
|
2020-09-23 21:50:51 +03:00
|
|
|
}
|
|
|
|
|
name = name + match cfg.output_type {
|
|
|
|
|
.html { '.html' }
|
|
|
|
|
.markdown { '.md' }
|
|
|
|
|
.json { '.json' }
|
|
|
|
|
else { '.txt' }
|
|
|
|
|
}
|
|
|
|
|
output := match cfg.output_type {
|
|
|
|
|
.html { cfg.gen_html(i) }
|
|
|
|
|
.markdown { cfg.gen_markdown(i, true) }
|
|
|
|
|
.json { cfg.gen_json(i) }
|
|
|
|
|
else { cfg.gen_plaintext(i) }
|
|
|
|
|
}
|
|
|
|
|
return name, output
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-15 16:17:52 +03:00
|
|
|
fn (cfg DocConfig) work_processor(mut work sync.Channel, mut wg sync.WaitGroup) {
|
2020-09-23 21:50:51 +03:00
|
|
|
for {
|
|
|
|
|
mut pdoc := ParallelDoc{}
|
|
|
|
|
if !work.pop(&pdoc) {
|
|
|
|
|
break
|
|
|
|
|
}
|
|
|
|
|
file_name, content := cfg.render_doc(pdoc.d, pdoc.i)
|
|
|
|
|
output_path := os.join_path(cfg.output_path, file_name)
|
2020-10-21 14:36:16 +03:00
|
|
|
println('Generating $output_path')
|
2020-09-23 21:50:51 +03:00
|
|
|
os.write_file(output_path, content)
|
|
|
|
|
}
|
|
|
|
|
wg.done()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn (cfg DocConfig) render_parallel() {
|
|
|
|
|
vjobs := runtime.nr_jobs()
|
|
|
|
|
mut work := sync.new_channel<ParallelDoc>(cfg.docs.len)
|
|
|
|
|
mut wg := sync.new_waitgroup()
|
|
|
|
|
for i in 0 .. cfg.docs.len {
|
|
|
|
|
p_doc := ParallelDoc{cfg.docs[i], i}
|
|
|
|
|
work.push(&p_doc)
|
|
|
|
|
}
|
|
|
|
|
work.close()
|
|
|
|
|
wg.add(vjobs)
|
|
|
|
|
for _ in 0 .. vjobs {
|
|
|
|
|
go cfg.work_processor(mut work, mut wg)
|
|
|
|
|
}
|
|
|
|
|
wg.wait()
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-05 10:59:26 +03:00
|
|
|
fn (cfg DocConfig) render() map[string]string {
|
2020-09-21 17:40:39 +03:00
|
|
|
mut docs := map[string]string{}
|
2020-06-02 13:10:01 +03:00
|
|
|
for i, doc in cfg.docs {
|
2020-09-23 21:50:51 +03:00
|
|
|
name, output := cfg.render_doc(doc, i)
|
2020-06-21 17:41:43 +03:00
|
|
|
docs[name] = output.trim_space()
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.vprintln('Rendered: ' + docs.keys().str())
|
2020-06-02 13:10:01 +03:00
|
|
|
return docs
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-23 21:50:51 +03:00
|
|
|
fn (mut cfg DocConfig) render_static() {
|
2020-10-21 14:36:16 +03:00
|
|
|
if cfg.output_type != .html {
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
cfg.assets = {
|
2020-10-21 14:36:16 +03:00
|
|
|
'doc_css': cfg.get_resource(css_js_assets[0], true)
|
|
|
|
|
'normalize_css': cfg.get_resource(css_js_assets[1], true)
|
|
|
|
|
'doc_js': cfg.get_resource(css_js_assets[2], !cfg.serve_http)
|
|
|
|
|
'light_icon': cfg.get_resource('light.svg', true)
|
|
|
|
|
'dark_icon': cfg.get_resource('dark.svg', true)
|
|
|
|
|
'menu_icon': cfg.get_resource('menu.svg', true)
|
2020-10-21 11:26:33 +03:00
|
|
|
'arrow_icon': cfg.get_resource('arrow.svg', true)
|
2020-09-23 21:50:51 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-07 13:27:42 +03:00
|
|
|
fn (cfg DocConfig) get_readme(path string) string {
|
|
|
|
|
mut fname := ''
|
|
|
|
|
for name in ['readme', 'README'] {
|
|
|
|
|
if os.exists(os.join_path(path, '${name}.md')) {
|
|
|
|
|
fname = name
|
|
|
|
|
break
|
2020-07-11 13:04:05 +03:00
|
|
|
}
|
2020-06-07 13:27:42 +03:00
|
|
|
}
|
|
|
|
|
if fname == '' {
|
|
|
|
|
return ''
|
|
|
|
|
}
|
|
|
|
|
readme_path := os.join_path(path, '${fname}.md')
|
|
|
|
|
cfg.vprintln('Reading README file from $readme_path')
|
2020-09-21 17:40:39 +03:00
|
|
|
readme_contents := os.read_file(readme_path) or {
|
|
|
|
|
''
|
|
|
|
|
}
|
2020-06-07 13:27:42 +03:00
|
|
|
return readme_contents
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-21 11:26:33 +03:00
|
|
|
fn (cfg DocConfig) emit_generate_err(err string, errcode int) {
|
|
|
|
|
mut err_msg := err
|
|
|
|
|
if errcode == 1 {
|
|
|
|
|
mod_list := get_modules_list(cfg.input_path, []string{})
|
|
|
|
|
println('Available modules:\n==================')
|
|
|
|
|
for mod in mod_list {
|
2020-10-21 14:36:16 +03:00
|
|
|
println(mod.all_after('vlib/').all_after('modules/').replace('/', '.'))
|
2020-10-21 11:26:33 +03:00
|
|
|
}
|
|
|
|
|
err_msg += ' Use the `-m` flag when generating docs from a directory that has multiple modules.'
|
|
|
|
|
}
|
|
|
|
|
eprintln(err_msg)
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-05 10:59:26 +03:00
|
|
|
fn (mut cfg DocConfig) generate_docs_from_file() {
|
|
|
|
|
if cfg.output_path.len == 0 {
|
|
|
|
|
if cfg.output_type == .unset {
|
|
|
|
|
cfg.output_type = .stdout
|
2020-06-02 13:10:01 +03:00
|
|
|
} else {
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.vprintln('No output path has detected. Using input path instead.')
|
|
|
|
|
cfg.output_path = cfg.input_path
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
} else if cfg.output_type == .unset {
|
|
|
|
|
cfg.vprintln('Output path detected. Identifying output type..')
|
|
|
|
|
ext := os.file_ext(cfg.output_path)
|
|
|
|
|
cfg.set_output_type_from_str(ext.all_after('.'))
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
if cfg.include_readme && cfg.output_type !in [.html, .stdout] {
|
2020-06-02 23:56:13 +03:00
|
|
|
eprintln('vdoc: Including README.md for doc generation is supported on HTML output, or when running directly in the terminal.')
|
2020-06-02 13:10:01 +03:00
|
|
|
exit(1)
|
|
|
|
|
}
|
2020-10-29 19:21:37 +03:00
|
|
|
dir_path := if cfg.is_vlib {
|
2020-06-05 15:22:50 +03:00
|
|
|
vexe_path
|
2020-07-11 13:04:05 +03:00
|
|
|
} else if os.is_dir(cfg.input_path) {
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.input_path
|
2020-07-11 13:04:05 +03:00
|
|
|
} else {
|
2020-10-01 02:30:22 +03:00
|
|
|
os.dir(cfg.input_path)
|
2020-06-05 10:59:26 +03:00
|
|
|
}
|
|
|
|
|
manifest_path := os.join_path(dir_path, 'v.mod')
|
|
|
|
|
if os.exists(manifest_path) {
|
|
|
|
|
cfg.vprintln('Reading v.mod info from $manifest_path')
|
2020-06-02 13:10:01 +03:00
|
|
|
if manifest := vmod.from_file(manifest_path) {
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.manifest = manifest
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
}
|
2020-06-07 13:27:42 +03:00
|
|
|
if cfg.include_readme {
|
|
|
|
|
readme_contents := cfg.get_readme(dir_path)
|
2020-07-04 15:29:00 +03:00
|
|
|
if cfg.output_type == .stdout {
|
2020-06-05 10:59:26 +03:00
|
|
|
println(markdown.to_plain(readme_contents))
|
2020-07-04 15:29:00 +03:00
|
|
|
} else if cfg.output_type == .html && cfg.is_multi {
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.docs << doc.Doc{
|
2020-06-02 23:56:13 +03:00
|
|
|
head: doc.DocNode{
|
2020-09-21 17:40:39 +03:00
|
|
|
name: 'README'
|
2020-06-02 23:56:13 +03:00
|
|
|
comment: readme_contents
|
|
|
|
|
}
|
2020-06-06 15:31:26 +03:00
|
|
|
time_generated: time.now()
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-07-04 15:29:00 +03:00
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-07-11 13:04:05 +03:00
|
|
|
dirs := if cfg.is_multi { get_modules_list(cfg.input_path, []string{}) } else { [cfg.input_path] }
|
2020-10-21 11:26:33 +03:00
|
|
|
is_local_and_single := cfg.is_local && !cfg.is_multi
|
2020-06-05 10:59:26 +03:00
|
|
|
for dirpath in dirs {
|
2020-10-21 11:26:33 +03:00
|
|
|
mut dcs := doc.Doc{}
|
2020-10-21 14:36:16 +03:00
|
|
|
cfg.vprintln('Generating docs for $dirpath')
|
2020-10-21 11:26:33 +03:00
|
|
|
if is_local_and_single {
|
2020-10-29 19:21:37 +03:00
|
|
|
dcs = doc.generate_with_pos(dirpath, cfg.local_filename, cfg.local_pos) or {
|
2020-10-21 11:26:33 +03:00
|
|
|
cfg.emit_generate_err(err, errcode)
|
2020-09-21 17:40:39 +03:00
|
|
|
exit(1)
|
2020-06-10 12:13:42 +03:00
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
} else {
|
2020-10-21 11:26:33 +03:00
|
|
|
dcs = doc.generate(dirpath, cfg.pub_only, true) or {
|
|
|
|
|
cfg.emit_generate_err(err, errcode)
|
2020-09-21 17:40:39 +03:00
|
|
|
exit(1)
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
}
|
|
|
|
|
if dcs.contents.len == 0 {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
if !is_local_and_single {
|
2020-09-21 17:40:39 +03:00
|
|
|
if cfg.is_multi || (!cfg.is_multi && cfg.include_readme) {
|
|
|
|
|
readme_contents := cfg.get_readme(dirpath)
|
|
|
|
|
dcs.head.comment = readme_contents
|
|
|
|
|
}
|
|
|
|
|
if cfg.pub_only {
|
2020-10-31 15:00:04 +03:00
|
|
|
for name, dc in dcs.contents {
|
|
|
|
|
dcs.contents[name].content = dc.content.all_after('pub ')
|
|
|
|
|
for i, cc in dc.children {
|
|
|
|
|
dcs.contents[name].children[i].content = cc.content.all_after('pub ')
|
2020-10-21 11:26:33 +03:00
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if !cfg.is_multi && cfg.symbol_name.len > 0 {
|
2020-10-21 11:26:33 +03:00
|
|
|
if cfg.symbol_name in dcs.contents {
|
2020-10-31 15:00:04 +03:00
|
|
|
for _, c in dcs.contents[cfg.symbol_name].children {
|
|
|
|
|
dcs.contents[c.name] = c
|
2020-09-21 17:40:39 +03:00
|
|
|
}
|
|
|
|
|
}
|
2020-06-06 15:31:26 +03:00
|
|
|
}
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
cfg.docs << dcs
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-10-29 19:21:37 +03:00
|
|
|
if cfg.is_vlib {
|
2020-06-29 12:03:09 +03:00
|
|
|
mut docs := cfg.docs.filter(it.head.name == 'builtin')
|
|
|
|
|
docs << cfg.docs.filter(it.head.name != 'builtin')
|
|
|
|
|
cfg.docs = docs
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
if cfg.serve_http {
|
|
|
|
|
cfg.serve_html()
|
2020-06-02 13:10:01 +03:00
|
|
|
return
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.vprintln('Rendering docs...')
|
2020-09-21 17:40:39 +03:00
|
|
|
if cfg.output_path.len == 0 || cfg.output_path == 'stdout' {
|
2020-09-23 21:50:51 +03:00
|
|
|
cfg.render_static()
|
2020-06-05 10:59:26 +03:00
|
|
|
outputs := cfg.render()
|
2020-06-21 17:51:02 +03:00
|
|
|
if outputs.len == 0 {
|
2020-06-08 09:22:10 +03:00
|
|
|
println('No documentation for $dirs')
|
|
|
|
|
} else {
|
|
|
|
|
first := outputs.keys()[0]
|
|
|
|
|
println(outputs[first])
|
|
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
} else {
|
2020-06-05 10:59:26 +03:00
|
|
|
if !os.is_dir(cfg.output_path) {
|
|
|
|
|
cfg.output_path = os.real_path('.')
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-06-19 11:36:45 +03:00
|
|
|
if !os.exists(cfg.output_path) {
|
|
|
|
|
os.mkdir(cfg.output_path) or {
|
|
|
|
|
panic(err)
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
if cfg.is_multi {
|
|
|
|
|
cfg.output_path = os.join_path(cfg.output_path, '_docs')
|
|
|
|
|
if !os.exists(cfg.output_path) {
|
|
|
|
|
os.mkdir(cfg.output_path) or {
|
2020-06-02 13:10:01 +03:00
|
|
|
panic(err)
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
} else {
|
2020-06-08 11:28:46 +03:00
|
|
|
for fname in css_js_assets {
|
2020-06-06 11:43:50 +03:00
|
|
|
os.rm(os.join_path(cfg.output_path, fname))
|
|
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
}
|
2020-09-23 21:50:51 +03:00
|
|
|
cfg.render_static()
|
|
|
|
|
cfg.render_parallel()
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-05 10:59:26 +03:00
|
|
|
fn (mut cfg DocConfig) set_output_type_from_str(format string) {
|
|
|
|
|
match format {
|
2020-09-21 17:40:39 +03:00
|
|
|
'htm', 'html' { cfg.output_type = .html }
|
|
|
|
|
'md', 'markdown' { cfg.output_type = .markdown }
|
|
|
|
|
'json' { cfg.output_type = .json }
|
|
|
|
|
'stdout' { cfg.output_type = .stdout }
|
|
|
|
|
else { cfg.output_type = .plaintext }
|
2020-06-05 10:59:26 +03:00
|
|
|
}
|
|
|
|
|
cfg.vprintln('Setting output type to "$cfg.output_type"')
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn (cfg DocConfig) vprintln(str string) {
|
|
|
|
|
if cfg.is_verbose {
|
|
|
|
|
println('vdoc: $str')
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-29 12:03:09 +03:00
|
|
|
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)
|
|
|
|
|
}
|
2020-10-03 17:40:22 +03:00
|
|
|
mut res := []string{}
|
2020-06-29 12:03:09 +03:00
|
|
|
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
|
|
|
|
|
}
|
2020-10-03 17:40:22 +03:00
|
|
|
res = final.map(os.join_path(path, it.trim_right('/')))
|
2020-06-29 12:03:09 +03:00
|
|
|
} else {
|
|
|
|
|
mut dirs := os.ls(path) or {
|
|
|
|
|
return []string{}
|
|
|
|
|
}
|
2020-10-03 17:40:22 +03:00
|
|
|
res = dirs.map(os.join_path(path, it)).filter(os.is_dir(it))
|
2020-06-29 12:03:09 +03:00
|
|
|
}
|
2020-10-03 17:40:22 +03:00
|
|
|
return res.map(it.replace('/', os.path_separator))
|
2020-06-29 12:03:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn is_included(path string, ignore_paths []string) bool {
|
|
|
|
|
if path.len == 0 {
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
for ignore_path in ignore_paths {
|
2020-09-21 17:40:39 +03:00
|
|
|
if ignore_path !in path {
|
|
|
|
|
continue
|
|
|
|
|
}
|
2020-06-29 12:03:09 +03:00
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn get_modules_list(path string, ignore_paths2 []string) []string {
|
2020-09-21 17:40:39 +03:00
|
|
|
files := os.ls(path) or {
|
|
|
|
|
return []string{}
|
|
|
|
|
}
|
|
|
|
|
mut ignore_paths := get_ignore_paths(path) or {
|
|
|
|
|
[]string{}
|
|
|
|
|
}
|
2020-06-29 12:03:09 +03:00
|
|
|
ignore_paths << ignore_paths2
|
2020-06-02 13:10:01 +03:00
|
|
|
mut dirs := []string{}
|
|
|
|
|
for file in files {
|
2020-06-29 12:03:09 +03:00
|
|
|
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') {
|
2020-09-21 17:40:39 +03:00
|
|
|
if path in dirs {
|
|
|
|
|
continue
|
|
|
|
|
}
|
2020-06-29 12:03:09 +03:00
|
|
|
dirs << path
|
|
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
|
|
|
|
dirs.sort()
|
|
|
|
|
return dirs
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-05 10:59:26 +03:00
|
|
|
fn (cfg DocConfig) get_resource(name string, minify bool) string {
|
2020-06-05 00:50:59 +03:00
|
|
|
path := os.join_path(res_path, name)
|
2020-09-21 17:40:39 +03:00
|
|
|
mut res := os.read_file(path) or {
|
2020-10-21 11:26:33 +03:00
|
|
|
panic('vdoc: could not read $path')
|
2020-09-21 17:40:39 +03:00
|
|
|
}
|
2020-06-05 00:50:59 +03:00
|
|
|
if minify {
|
2020-06-29 12:03:09 +03:00
|
|
|
if name.ends_with('.js') {
|
2020-07-11 13:04:05 +03:00
|
|
|
res = js_compress(res)
|
|
|
|
|
} else {
|
2020-06-29 12:03:09 +03:00
|
|
|
res = res.split_into_lines().map(it.trim_space()).join('')
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
}
|
|
|
|
|
// TODO: Make SVG inline for now
|
|
|
|
|
if cfg.inline_assets || path.ends_with('.svg') {
|
|
|
|
|
return res
|
|
|
|
|
} else {
|
|
|
|
|
output_path := os.join_path(cfg.output_path, name)
|
|
|
|
|
if !os.exists(output_path) {
|
2020-10-21 14:36:16 +03:00
|
|
|
println('Generating $output_path')
|
2020-06-05 10:59:26 +03:00
|
|
|
os.write_file(output_path, res)
|
|
|
|
|
}
|
|
|
|
|
return name
|
2020-06-05 00:50:59 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-02 13:10:01 +03:00
|
|
|
fn main() {
|
2020-06-21 17:41:43 +03:00
|
|
|
args := os.args[2..].clone()
|
2020-06-06 18:41:44 +03:00
|
|
|
if args.len == 0 || args[0] in ['help', '-h', '--help'] {
|
2020-06-05 16:57:16 +03:00
|
|
|
os.system('${@VEXE} help doc')
|
2020-06-02 13:10:01 +03:00
|
|
|
exit(0)
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
mut cfg := DocConfig{
|
2020-09-21 17:40:39 +03:00
|
|
|
manifest: vmod.Manifest{
|
|
|
|
|
repo_url: ''
|
|
|
|
|
}
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
for i := 0; i < args.len; i++ {
|
|
|
|
|
arg := args[i]
|
|
|
|
|
current_args := args[i..]
|
|
|
|
|
match arg {
|
|
|
|
|
'-all' {
|
|
|
|
|
cfg.pub_only = false
|
|
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
'-filename' {
|
|
|
|
|
cfg.is_local = true
|
|
|
|
|
cfg.local_filename = cmdline.option(current_args, '-filename', '')
|
|
|
|
|
i++
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
'-f' {
|
|
|
|
|
format := cmdline.option(current_args, '-f', '')
|
|
|
|
|
if format !in allowed_formats {
|
2020-09-23 21:50:51 +03:00
|
|
|
allowed_str := allowed_formats.join(', ')
|
2020-06-05 10:59:26 +03:00
|
|
|
eprintln('vdoc: "$format" is not a valid format. Only $allowed_str are allowed.')
|
|
|
|
|
exit(1)
|
|
|
|
|
}
|
|
|
|
|
cfg.set_output_type_from_str(format)
|
|
|
|
|
i++
|
|
|
|
|
}
|
|
|
|
|
'-inline-assets' {
|
|
|
|
|
cfg.inline_assets = true
|
|
|
|
|
}
|
|
|
|
|
'-l' {
|
|
|
|
|
cfg.show_loc = true
|
|
|
|
|
}
|
|
|
|
|
'-m' {
|
|
|
|
|
cfg.is_multi = true
|
|
|
|
|
}
|
|
|
|
|
'-o' {
|
|
|
|
|
opath := cmdline.option(current_args, '-o', '')
|
2020-09-21 17:40:39 +03:00
|
|
|
cfg.output_path = if opath == 'stdout' { opath } else { os.real_path(opath) }
|
2020-06-05 10:59:26 +03:00
|
|
|
i++
|
|
|
|
|
}
|
2020-06-07 13:27:42 +03:00
|
|
|
'-open' {
|
|
|
|
|
cfg.open_docs = true
|
|
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
'-pos' {
|
|
|
|
|
if !cfg.is_local {
|
|
|
|
|
eprintln('vdoc: `-pos` is only allowed with `-filename` flag.')
|
|
|
|
|
exit(1)
|
|
|
|
|
}
|
|
|
|
|
cfg.local_pos = cmdline.option(current_args, '-pos', '').int()
|
|
|
|
|
i++
|
|
|
|
|
}
|
2020-06-07 13:27:42 +03:00
|
|
|
'-p' {
|
|
|
|
|
s_port := cmdline.option(current_args, '-o', '')
|
|
|
|
|
s_port_int := s_port.int()
|
|
|
|
|
if s_port.len == 0 {
|
|
|
|
|
eprintln('vdoc: No port number specified on "-p".')
|
|
|
|
|
exit(1)
|
|
|
|
|
}
|
|
|
|
|
if s_port != s_port_int.str() {
|
|
|
|
|
eprintln('vdoc: Invalid port number.')
|
|
|
|
|
exit(1)
|
|
|
|
|
}
|
|
|
|
|
cfg.server_port = s_port_int
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
'-s' {
|
|
|
|
|
cfg.inline_assets = true
|
|
|
|
|
cfg.serve_http = true
|
2020-06-19 11:36:45 +03:00
|
|
|
if cfg.output_type == .unset {
|
|
|
|
|
cfg.output_type = .html
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
}
|
2020-10-19 22:30:37 +03:00
|
|
|
'-no-timestamp' {
|
|
|
|
|
cfg.no_timestamp = true
|
|
|
|
|
}
|
2020-06-19 11:36:45 +03:00
|
|
|
'-readme' {
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.include_readme = true
|
|
|
|
|
}
|
|
|
|
|
'-v' {
|
|
|
|
|
cfg.is_verbose = true
|
|
|
|
|
}
|
|
|
|
|
else {
|
2020-09-21 17:40:39 +03:00
|
|
|
if cfg.input_path.len < 1 {
|
|
|
|
|
cfg.input_path = arg
|
|
|
|
|
} else {
|
|
|
|
|
cfg.symbol_name = arg
|
|
|
|
|
}
|
|
|
|
|
if i == args.len - 1 {
|
|
|
|
|
break
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if cfg.input_path.len == 0 {
|
|
|
|
|
eprintln('vdoc: No input path found.')
|
|
|
|
|
exit(1)
|
|
|
|
|
}
|
2020-10-21 11:26:33 +03:00
|
|
|
if cfg.output_path == 'stdout' && cfg.output_type == .html {
|
|
|
|
|
cfg.inline_assets = true
|
|
|
|
|
}
|
2020-06-19 11:36:45 +03:00
|
|
|
$if windows {
|
|
|
|
|
cfg.input_path = cfg.input_path.replace('/', os.path_separator)
|
|
|
|
|
} $else {
|
|
|
|
|
cfg.input_path = cfg.input_path.replace('\\', os.path_separator)
|
|
|
|
|
}
|
2020-09-21 17:40:39 +03:00
|
|
|
is_path := cfg.input_path.ends_with('.v') || cfg.input_path.split(os.path_separator).len >
|
|
|
|
|
1 || cfg.input_path == '.'
|
2020-06-05 10:59:26 +03:00
|
|
|
if cfg.input_path == 'vlib' {
|
2020-10-29 19:21:37 +03:00
|
|
|
cfg.is_vlib = true
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.is_multi = true
|
2020-06-05 15:22:50 +03:00
|
|
|
cfg.input_path = os.join_path(vexe_path, 'vlib')
|
2020-06-05 10:59:26 +03:00
|
|
|
} else if !is_path {
|
|
|
|
|
cfg.vprintln('Input "$cfg.input_path" is not a valid path. Looking for modules named "$cfg.input_path"...')
|
2020-10-21 11:26:33 +03:00
|
|
|
mod_path := doc.lookup_module(cfg.input_path) or {
|
|
|
|
|
eprintln('vdoc: $err')
|
2020-06-02 13:10:01 +03:00
|
|
|
exit(1)
|
|
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.input_path = mod_path
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
2020-06-05 10:59:26 +03:00
|
|
|
cfg.generate_docs_from_file()
|
2020-06-02 13:10:01 +03:00
|
|
|
}
|
