使用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)
    }
}