使用Go语言编写一个毫秒级生成组件库文档工具

var rootcommand = &cobra.command{
    use:   "nk",
    short: "nk: 一个神奇的文档生成工具",
    long:  "nk是一个强大的文档生成工具，旨在提供快速而高效的文档生成体验。",
}

var generatecommand = &cobra.command{
    use:     "generate",
    aliases: []string{"g"},
    short:   "generate: 启动文档生成",
    long:    "generate命令用于启动文档生成。",
}

var doccommand = &cobra.command{
    use:   "doc",
    short: "generate doc project: 生成文档项目",
    long:  "doc命令用于生成文档项目。",
    run:   rundoccommand,
}

func initdoccommand() {
    wd, err := os.getwd()
    if err != nil {
        return
    }

    // 声明命令参数
    doccommand.flags().string("components-dir", path.join(wd, "projects", "components"), "指定组件目录的绝对路径")
    doccommand.flags().string("doc-dir", path.join(wd, "projects", "design-doc"), "指定设计文档目录的绝对路径")
    doccommand.flags().string("docs-dir", path.join(wd, "docs"), "指定文档目录的绝对路径")
    doccommand.flags().bool("watch", true, "监听文件变化")
}

func init() {
    initdoccommand()
    generatecommand.addcommand(doccommand)
    generatecommand.addcommand(servicecommand)
    generatecommand.addcommand(staticiconscommand)
    rootcommand.addcommand(generatecommand)
}

nx g doc --components-dir xxxx

type task struct {
    name         string          // 任务名称
    work         func() error   // 任务执行的函数
    dependencies []*task        // 依赖的任务
    mu           sync.mutex     // 互斥锁，用于同步
    cond         *sync.cond     // 条件变量，用于等待任务完成
    done         bool           // 任务完成标志
    starttime    time.time      // 任务开始时间
    endtime      time.time      // 任务结束时间
    nooutputlog  bool           // 是否输出日志
}

// printexecutiontime 输出任务执行时间
func printexecutiontime(task *task) {
    executiontime := task.endtime.sub(task.starttime).milliseconds()
    color.green.println(fmt.sprintf("[%s] 任务完成 执行时间：%d 毫秒", task.name, executiontime))
}

// newtask 创建一个新任务
func newtask(name string, work func() error) *task {
    task := &task{
        name: name,
        work: work,
        done: false,
    }
    task.cond = sync.newcond(&task.mu)
    return task
}

// setdependency 设置任务的依赖关系
func (t *task) setdependency(dependencies ...*task) {
    t.dependencies = append(t.dependencies, dependencies...)
}

// waitfordependencies 等待任务的依赖任务完成
func (t *task) waitfordependencies() {
    for _, dep := range t.dependencies {
        dep.waitforcompletion()
    }
}

// run 运行任务
func (t *task) run() error {
    t.waitfordependencies()

    t.mu.lock()
    defer t.mu.unlock()

    t.starttime = time.now()
    if !t.nooutputlog {
        color.green.println(fmt.sprintf("[%s] 任务开始", t.name))
    }
    err := t.work()
    if err != nil {
        return err
    }
    t.endtime = time.now()

    t.done = true
    if !t.nooutputlog {
        printexecutiontime(t)
    }
    t.cond.broadcast()

    return nil
}

// waitforcompletion 等待任务完成
func (t *task) waitforcompletion() {
    t.mu.lock()
    defer t.mu.unlock()

    for !t.done {
        t.cond.wait()
    }
}

// serialtask 串行执行任务
func serialtask(tasks []*task) {
    for _, task := range tasks {
        task.run()
    }
}

// paralleltask 并行执行任务
func paralleltask(tasks []*task) {
    var wg sync.waitgroup

    for _, task := range tasks {
        wg.add(1)
        go func(t *task) {
            defer wg.done()
            t.run()
        }(task)
    }

    wg.wait()
}

var clearcachetask = flows.newtask("清除项目缓存", func() error {
    return nil
})
var copyprojecttask = flows.newtask("复制项目模板", func() error {
    return nil
})
// 设置依赖 copyprojecttask 依赖 clearcachetask任务
copyprojecttask.setdependency(clearcachetask)
var collecttemplatemetatask = flows.newtask("收集模板信息", func() error {
    return nil
})
flows.paralleltask([]*flows.task{
    clearcachetask,
    copyprojecttask,
    collecttemplatemetatask,
})

func converttohtml(markdowncontent string) string {
    var htmloutput bytes.buffer

    md := goldmark.new(
        goldmark.withextensions(extension.gfm),  // 支持github风格的markdown
        // 如果需要语法高亮，可以启用以下代码（需要配置chroma等选项）
        //goldmark.withextensions(
        //    highlighting.newhighlighting(
        //        highlighting.withstyle("github"),
        //        highlighting.withformatoptions(
        //            chromahtml.withclasses(true),
        //        ),
        //    ),
        //),
        goldmark.withrenderer(htmlrenderer()),  // 使用自定义的html渲染器
        goldmark.withrendereroptions(html.withunsafe()),  // 允许html渲染器输出不安全的html
    )

    if err := md.convert([]byte(markdowncontent), &htmloutput); err != nil {
        panic(err)
    }

    return htmloutput.string()
}

// customhtmlrenderer 自定义渲染器
type customhtmlrenderer struct {
 html.renderer
}

func htmlrenderer() renderer.renderer {
 return renderer.newrenderer(renderer.withnoderenderers(util.prioritized(newrenderer(), 1000)))
}

func newrenderer(opts ...html.option) renderer.noderenderer {
 r := &customhtmlrenderer{
  renderer: html.renderer{
   config: html.newconfig(),
  },
 }

 for _, opt := range opts {
  opt.sethtmloption(&r.config)
 }

 return r
}

// renderheading 自定义标签渲染
func (r *customhtmlrenderer) renderheading(
 w util.bufwriter, source []byte, node ast.node, entering bool) (ast.walkstatus, error) {
 n := node.(*ast.heading)
 if entering {
  lines := n.baseblock.lines()
  if lines.len() > 0 {
   at := n.baseblock.lines().at(0)
   buf := at.value(source)
   // 附加id
   n.setattribute([]byte("id"), buf)
  }

  _, _ = w.writestring("<h")
  _ = w.writebyte("0123456"[n.level])
  if n.attributes() != nil {
   html.renderattributes(w, node, html.headingattributefilter)
  }
  _ = w.writebyte('>')
 } else {
  _, _ = w.writestring("</h")
  _ = w.writebyte("0123456"[n.level])
  _, _ = w.writestring(">\n")
 }
 return ast.walkcontinue, nil
}

func (r *customhtmlrenderer) registerfuncs(reg renderer.noderendererfuncregisterer) {
 r.renderer.registerfuncs(reg)
 // 注册 覆盖内置的标题渲染逻辑
 reg.register(ast.kindheading, r.renderheading)
}

func parsemarkdown(filepath string) (*document, error) {
    // 读取markdown文件内容
    mdcontent, err := ioutil.readfile(filepath)
    if err != nil {
        return nil, err
    }

    // 使用正则表达式提取yaml元数据部分
    re := regexp.mustcompile(`---\r*\n([\s\s]*?)\r*\n---`)
    match := re.findstringsubmatch(string(mdcontent))
    if len(match) < 2 {
        return nil, fmt.errorf("yaml section not found")
    }

    // 获取yaml元数据内容
    yamlcontent := match[1]
    // 获取除去yaml元数据的markdown内容
    markdowncontent := string(mdcontent)[len(yamlcontent)+8:]

    // 解析yaml元数据
    var metadata metadata
    if err := yaml.unmarshal([]byte(yamlcontent), &metadata); err != nil {
        return nil, fmt.errorf("error parsing yaml: %w", err)
    }

    // 获取文件名（包括扩展名）
    filenamewithextension := filepath.base(filepath)
    // 去除扩展名，获得文件名
    filename := strings.trimsuffix(filenamewithextension, filepath.ext(filenamewithextension))

    // 创建文档对象，包括元数据和多语言html内容
    document := document{
        metadata: metadata,
        zhcn:     converttohtml(getsectioncontent(markdowncontent, "zh-cn")),
        enus:     converttohtml(getsectioncontent(markdowncontent, "en-us")),
        filekey:  filename,
    }

    return &document, nil
}

func wrapperanchor(content string, anchor string) string {
 return fmt.sprintf(
  "<div class="doc-content">\n\t\t%s\n</div><nx-anchor container="#component-demo">%s</nx-anchor>", content, anchor)
}
// ...
templatestring += wrapperanchor(angularnonbindable(templatecontent), strings.join(anchorlink, "\n"))

// registrationtask 注册相关子任务&处理任务之间的依赖关系
func (receiver *compiledoctask) registrationtask() {
    // 创建清除 design-doc 任务
    receiver.cleardesigndoctask = flows.newtask("清除 design-doc", receiver.cleartaskhandler)
    
    // 创建复制 design-doc 任务
    receiver.copydesigndoctask = flows.newtask("复制 design-doc", receiver.copydocprojecttaskhandler)
    
    // 设置复制任务依赖于清除任务
    receiver.copydesigndoctask.setdependency(receiver.cleardesigndoctask)
    
    // 创建收集全局文档信息任务
    receiver.collectglobaldocstask = flows.newtask("收集全局文档信息", receiver.collectglobaldocstaskhandler)
    
    // 创建收集组件文档信息任务
    receiver.collectcomponentdocstask = flows.newtask("收集组件文档信息", receiver.collectcomponentdocstaskhandler)
    
    // 创建生成全局文档任务
    receiver.generateglobaldocstask = flows.newtask("生成全局文档", receiver.generateglobaldocstaskhandler)
    
    // 设置生成全局文档任务依赖于复制和收集任务
    receiver.generateglobaldocstask.setdependency(
        receiver.copydesigndoctask,
        receiver.collectglobaldocstask,
    )
    
    // 创建生成demo文档任务
    receiver.generatedemodocstask = flows.newtask("生成demo文档", receiver.generatedemodocstaskhandler)
    
    // 设置生成demo文档任务依赖于收集组件文档信息任务
    receiver.generatedemodocstask.setdependency(receiver.collectcomponentdocstask)
}

// compiletask 编译文档 处理元数据收集，md文档解析等
func (receiver *compiledoctask) compiletask() {
    // 并行执行清除、复制、收集任务
    flows.paralleltask([]*flows.task{
        receiver.cleardesigndoctask,
        receiver.copydesigndoctask,
        receiver.collectcomponentdocstask,
        receiver.collectglobaldocstask,
    })
}

// generatetask 将收集的信息整合到一起生成完整的组件库文档
func (receiver *compiledoctask) generatetask() {
    // 并行执行生成全局文档和生成demo文档任务
    flows.paralleltask([]*flows.task{
        receiver.generateglobaldocstask,
        receiver.generatedemodocstask,
    })
}

func rundoccommand(cmd *cobra.command, _ []string) {
    componentsdir, _ := cmd.flags().getstring("components-dir")
    docdir, _ := cmd.flags().getstring("doc-dir")
    docsdir, _ := cmd.flags().getstring("docs-dir")
    watch, _ := cmd.flags().getbool("watch")
    sourcedir := path.join("design-doc") // 源目录
    
    // 创建文档生成任务
    compiledoctask := newcompiledoctask(componentsdir, docdir, docsdir, sourcedir)
    
    // 执行编译任务
    compiledoctask.compiletask()
    
    // 执行生成任务
    compiledoctask.generatetask()
    
    if watch {
        // 监听单个文件的变化 实现局部更新
        watchdoc(cmd, compiledoctask)
    }
}