mirror of
https://github.com/siyuan-note/siyuan.git
synced 2025-12-16 06:30:14 +01:00
689 lines
18 KiB
Go
689 lines
18 KiB
Go
// SiYuan - Refactor your thinking
|
||
// Copyright (c) 2020-present, b3log.org
|
||
//
|
||
// This program is free software: you can redistribute it and/or modify
|
||
// it under the terms of the GNU Affero General Public License as published by
|
||
// the Free Software Foundation, either version 3 of the License, or
|
||
// (at your option) any later version.
|
||
//
|
||
// This program is distributed in the hope that it will be useful,
|
||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
// GNU Affero General Public License for more details.
|
||
//
|
||
// You should have received a copy of the GNU Affero General Public License
|
||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
package model
|
||
|
||
import (
|
||
"os"
|
||
"path/filepath"
|
||
"sort"
|
||
"strings"
|
||
"unicode/utf8"
|
||
|
||
"github.com/88250/gulu"
|
||
"github.com/88250/lute/ast"
|
||
"github.com/88250/lute/editor"
|
||
"github.com/88250/lute/parse"
|
||
"github.com/emirpasic/gods/sets/hashset"
|
||
"github.com/siyuan-note/logging"
|
||
"github.com/siyuan-note/siyuan/kernel/av"
|
||
"github.com/siyuan-note/siyuan/kernel/filesys"
|
||
"github.com/siyuan-note/siyuan/kernel/sql"
|
||
"github.com/siyuan-note/siyuan/kernel/treenode"
|
||
"github.com/siyuan-note/siyuan/kernel/util"
|
||
)
|
||
|
||
type BlockInfo struct {
|
||
ID string `json:"id"`
|
||
RootID string `json:"rootID"`
|
||
Name string `json:"name"`
|
||
RefCount int `json:"refCount"`
|
||
SubFileCount int `json:"subFileCount"`
|
||
RefIDs []string `json:"refIDs"`
|
||
IAL map[string]string `json:"ial"`
|
||
Icon string `json:"icon"`
|
||
AttrViews []*AttrView `json:"attrViews"`
|
||
}
|
||
|
||
type AttrView struct {
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
}
|
||
|
||
func GetDocInfo(blockID string) (ret *BlockInfo) {
|
||
FlushTxQueue()
|
||
|
||
tree, err := LoadTreeByBlockID(blockID)
|
||
if err != nil {
|
||
logging.LogErrorf("load tree by root id [%s] failed: %s", blockID, err)
|
||
return
|
||
}
|
||
|
||
title := tree.Root.IALAttr("title")
|
||
ret = &BlockInfo{ID: blockID, RootID: tree.Root.ID, Name: title}
|
||
ret.IAL = parse.IAL2Map(tree.Root.KramdownIAL)
|
||
scrollData := ret.IAL["scroll"]
|
||
if 0 < len(scrollData) {
|
||
scroll := map[string]interface{}{}
|
||
if parseErr := gulu.JSON.UnmarshalJSON([]byte(scrollData), &scroll); nil != parseErr {
|
||
logging.LogWarnf("parse scroll data [%s] failed: %s", scrollData, parseErr)
|
||
delete(ret.IAL, "scroll")
|
||
} else {
|
||
if zoomInId := scroll["zoomInId"]; nil != zoomInId {
|
||
if !treenode.ExistBlockTree(zoomInId.(string)) {
|
||
delete(ret.IAL, "scroll")
|
||
}
|
||
} else {
|
||
if startId := scroll["startId"]; nil != startId {
|
||
if !treenode.ExistBlockTree(startId.(string)) {
|
||
delete(ret.IAL, "scroll")
|
||
}
|
||
}
|
||
if endId := scroll["endId"]; nil != endId {
|
||
if !treenode.ExistBlockTree(endId.(string)) {
|
||
delete(ret.IAL, "scroll")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bt := treenode.GetBlockTree(blockID)
|
||
refDefs := queryBlockRefDefs(bt)
|
||
buildBacklinkListItemRefs(refDefs)
|
||
var refIDs []string
|
||
for _, refDef := range refDefs {
|
||
refIDs = append(refIDs, refDef.RefID)
|
||
}
|
||
if 1 > len(refIDs) {
|
||
refIDs = []string{}
|
||
}
|
||
ret.RefIDs = refIDs
|
||
ret.RefCount = len(ret.RefIDs)
|
||
|
||
// 填充属性视图角标 Display the database title on the block superscript https://github.com/siyuan-note/siyuan/issues/10545
|
||
avIDs := strings.Split(ret.IAL[av.NodeAttrNameAvs], ",")
|
||
for _, avID := range avIDs {
|
||
avName, getErr := av.GetAttributeViewName(avID)
|
||
if nil != getErr {
|
||
continue
|
||
}
|
||
|
||
if "" == avName {
|
||
avName = Conf.language(105)
|
||
}
|
||
|
||
attrView := &AttrView{ID: avID, Name: avName}
|
||
ret.AttrViews = append(ret.AttrViews, attrView)
|
||
}
|
||
|
||
var subFileCount int
|
||
boxLocalPath := filepath.Join(util.DataDir, tree.Box)
|
||
subFiles, err := os.ReadDir(filepath.Join(boxLocalPath, strings.TrimSuffix(tree.Path, ".sy")))
|
||
if err == nil {
|
||
for _, subFile := range subFiles {
|
||
if strings.HasSuffix(subFile.Name(), ".sy") {
|
||
subFileCount++
|
||
}
|
||
}
|
||
}
|
||
ret.SubFileCount = subFileCount
|
||
ret.Icon = tree.Root.IALAttr("icon")
|
||
return
|
||
}
|
||
|
||
func GetDocsInfo(blockIDs []string, queryRefCount bool, queryAv bool) (rets []*BlockInfo) {
|
||
FlushTxQueue()
|
||
|
||
trees := filesys.LoadTrees(blockIDs)
|
||
bts := treenode.GetBlockTrees(blockIDs)
|
||
for _, blockID := range blockIDs {
|
||
tree := trees[blockID]
|
||
if nil == tree {
|
||
continue
|
||
}
|
||
title := tree.Root.IALAttr("title")
|
||
ret := &BlockInfo{ID: blockID, RootID: tree.Root.ID, Name: title}
|
||
ret.IAL = parse.IAL2Map(tree.Root.KramdownIAL)
|
||
scrollData := ret.IAL["scroll"]
|
||
if 0 < len(scrollData) {
|
||
scroll := map[string]interface{}{}
|
||
if parseErr := gulu.JSON.UnmarshalJSON([]byte(scrollData), &scroll); nil != parseErr {
|
||
logging.LogWarnf("parse scroll data [%s] failed: %s", scrollData, parseErr)
|
||
delete(ret.IAL, "scroll")
|
||
} else {
|
||
if zoomInId := scroll["zoomInId"]; nil != zoomInId {
|
||
if !treenode.ExistBlockTree(zoomInId.(string)) {
|
||
delete(ret.IAL, "scroll")
|
||
}
|
||
} else {
|
||
if startId := scroll["startId"]; nil != startId {
|
||
if !treenode.ExistBlockTree(startId.(string)) {
|
||
delete(ret.IAL, "scroll")
|
||
}
|
||
}
|
||
if endId := scroll["endId"]; nil != endId {
|
||
if !treenode.ExistBlockTree(endId.(string)) {
|
||
delete(ret.IAL, "scroll")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if queryRefCount {
|
||
var refIDs []string
|
||
refDefs := queryBlockRefDefs(bts[blockID])
|
||
buildBacklinkListItemRefs(refDefs)
|
||
for _, refDef := range refDefs {
|
||
refIDs = append(refIDs, refDef.RefID)
|
||
}
|
||
if 1 > len(refIDs) {
|
||
refIDs = []string{}
|
||
}
|
||
ret.RefIDs = refIDs
|
||
ret.RefCount = len(ret.RefIDs)
|
||
}
|
||
|
||
if queryAv {
|
||
// 填充属性视图角标 Display the database title on the block superscript https://github.com/siyuan-note/siyuan/issues/10545
|
||
avIDs := strings.Split(ret.IAL[av.NodeAttrNameAvs], ",")
|
||
for _, avID := range avIDs {
|
||
avName, getErr := av.GetAttributeViewName(avID)
|
||
if nil != getErr {
|
||
continue
|
||
}
|
||
|
||
if "" == avName {
|
||
avName = Conf.language(105)
|
||
}
|
||
|
||
attrView := &AttrView{ID: avID, Name: avName}
|
||
ret.AttrViews = append(ret.AttrViews, attrView)
|
||
}
|
||
}
|
||
|
||
var subFileCount int
|
||
boxLocalPath := filepath.Join(util.DataDir, tree.Box)
|
||
subFiles, err := os.ReadDir(filepath.Join(boxLocalPath, strings.TrimSuffix(tree.Path, ".sy")))
|
||
if err == nil {
|
||
for _, subFile := range subFiles {
|
||
if strings.HasSuffix(subFile.Name(), ".sy") {
|
||
subFileCount++
|
||
}
|
||
}
|
||
}
|
||
ret.SubFileCount = subFileCount
|
||
ret.Icon = tree.Root.IALAttr("icon")
|
||
|
||
rets = append(rets, ret)
|
||
|
||
}
|
||
return
|
||
}
|
||
|
||
func GetBlockRefText(id string) string {
|
||
FlushTxQueue()
|
||
|
||
bt := treenode.GetBlockTree(id)
|
||
if nil == bt {
|
||
return ErrBlockNotFound.Error()
|
||
}
|
||
|
||
tree, err := LoadTreeByBlockID(id)
|
||
if err != nil {
|
||
return ""
|
||
}
|
||
|
||
node := treenode.GetNodeInTree(tree, id)
|
||
if nil == node {
|
||
return ErrBlockNotFound.Error()
|
||
}
|
||
|
||
ast.Walk(node, func(n *ast.Node, entering bool) ast.WalkStatus {
|
||
if !entering {
|
||
return ast.WalkContinue
|
||
}
|
||
|
||
if n.IsTextMarkType("inline-memo") {
|
||
// Block ref anchor text no longer contains contents of inline-level memos https://github.com/siyuan-note/siyuan/issues/9363
|
||
n.TextMarkInlineMemoContent = ""
|
||
return ast.WalkContinue
|
||
}
|
||
return ast.WalkContinue
|
||
})
|
||
return getNodeRefText(node)
|
||
}
|
||
|
||
func GetDOMText(dom string) (ret string) {
|
||
luteEngine := NewLute()
|
||
tree := luteEngine.BlockDOM2Tree(dom)
|
||
ret = renderBlockText(tree.Root.FirstChild, nil, true)
|
||
return
|
||
}
|
||
|
||
func getBlockRefText(id string, tree *parse.Tree) (ret string) {
|
||
node := treenode.GetNodeInTree(tree, id)
|
||
if nil == node {
|
||
return
|
||
}
|
||
|
||
ret = getNodeRefText(node)
|
||
ret = maxContent(ret, Conf.Editor.BlockRefDynamicAnchorTextMaxLen)
|
||
return
|
||
}
|
||
|
||
func getNodeRefText(node *ast.Node) string {
|
||
if nil == node {
|
||
return ""
|
||
}
|
||
|
||
if ret := node.IALAttr("name"); "" != ret {
|
||
ret = strings.TrimSpace(ret)
|
||
ret = util.EscapeHTML(ret)
|
||
return ret
|
||
}
|
||
return getNodeRefText0(node, Conf.Editor.BlockRefDynamicAnchorTextMaxLen, true)
|
||
}
|
||
|
||
func getNodeAvBlockText(node *ast.Node, avID string) (icon, content string) {
|
||
if nil == node {
|
||
return
|
||
}
|
||
|
||
icon = node.IALAttr("icon")
|
||
if name := node.IALAttr("name"); "" != name {
|
||
name = strings.TrimSpace(name)
|
||
name = util.EscapeHTML(name)
|
||
content = name
|
||
} else {
|
||
content = getNodeRefText0(node, 1024, false)
|
||
}
|
||
|
||
content = strings.TrimSpace(content)
|
||
if "" != avID {
|
||
if staticText := node.IALAttr(av.NodeAttrViewStaticText + "-" + avID); "" != staticText {
|
||
content = staticText
|
||
}
|
||
}
|
||
if "" == content {
|
||
content = Conf.language(105)
|
||
}
|
||
return
|
||
}
|
||
|
||
func getNodeRefText0(node *ast.Node, maxLen int, removeLineBreak bool) string {
|
||
switch node.Type {
|
||
case ast.NodeBlockQueryEmbed:
|
||
return "Query Embed Block..."
|
||
case ast.NodeIFrame:
|
||
return "IFrame..."
|
||
case ast.NodeThematicBreak:
|
||
return "Thematic Break..."
|
||
case ast.NodeVideo:
|
||
return "Video..."
|
||
case ast.NodeAudio:
|
||
return "Audio..."
|
||
case ast.NodeAttributeView:
|
||
ret, _ := av.GetAttributeViewName(node.AttributeViewID)
|
||
if "" == ret {
|
||
ret = "Database..."
|
||
}
|
||
return ret
|
||
}
|
||
|
||
if ast.NodeDocument != node.Type && node.IsContainerBlock() {
|
||
node = treenode.FirstLeafBlock(node)
|
||
}
|
||
ret := renderBlockText(node, nil, removeLineBreak)
|
||
if maxLen < utf8.RuneCountInString(ret) {
|
||
ret = gulu.Str.SubStr(ret, maxLen) + "..."
|
||
}
|
||
return ret
|
||
}
|
||
|
||
type RefDefs struct {
|
||
RefID string `json:"refID"`
|
||
DefIDs []string `json:"defIDs"`
|
||
}
|
||
|
||
func GetBlockRefs(defID string) (refDefs []*RefDefs, originalRefBlockIDs map[string]string) {
|
||
refDefs = []*RefDefs{}
|
||
originalRefBlockIDs = map[string]string{}
|
||
bt := treenode.GetBlockTree(defID)
|
||
if nil == bt {
|
||
return
|
||
}
|
||
|
||
refDefs = queryBlockRefDefs(bt)
|
||
originalRefBlockIDs = buildBacklinkListItemRefs(refDefs)
|
||
return
|
||
}
|
||
|
||
func queryBlockRefDefs(bt *treenode.BlockTree) (refDefs []*RefDefs) {
|
||
refDefs = []*RefDefs{}
|
||
if nil == bt {
|
||
return
|
||
}
|
||
|
||
isDoc := bt.ID == bt.RootID
|
||
if isDoc {
|
||
refDefIDs := sql.QueryChildRefDefIDsByRootDefID(bt.RootID)
|
||
for rID, dIDs := range refDefIDs {
|
||
var defIDs []string
|
||
for _, dID := range dIDs {
|
||
defIDs = append(defIDs, dID)
|
||
}
|
||
if 1 > len(defIDs) {
|
||
defIDs = []string{}
|
||
}
|
||
refDefs = append(refDefs, &RefDefs{RefID: rID, DefIDs: defIDs})
|
||
}
|
||
} else {
|
||
refIDs := sql.QueryRefIDsByDefID(bt.ID, false)
|
||
for _, refID := range refIDs {
|
||
refDefs = append(refDefs, &RefDefs{RefID: refID, DefIDs: []string{bt.ID}})
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func GetBlockRefIDsByFileAnnotationID(id string) []string {
|
||
return sql.QueryRefIDsByAnnotationID(id)
|
||
}
|
||
|
||
func GetBlockDefIDsByRefText(refText string, excludeIDs []string) (ret []string) {
|
||
ret = sql.QueryBlockDefIDsByRefText(refText, excludeIDs)
|
||
sort.Sort(sort.Reverse(sort.StringSlice(ret)))
|
||
if 1 > len(ret) {
|
||
ret = []string{}
|
||
}
|
||
return
|
||
}
|
||
|
||
func GetBlockIndex(id string) (ret int) {
|
||
tree, _ := LoadTreeByBlockID(id)
|
||
if nil == tree {
|
||
return
|
||
}
|
||
node := treenode.GetNodeInTree(tree, id)
|
||
if nil == node {
|
||
return
|
||
}
|
||
|
||
rootChild := node
|
||
for ; nil != rootChild.Parent && ast.NodeDocument != rootChild.Parent.Type; rootChild = rootChild.Parent {
|
||
}
|
||
|
||
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
|
||
if !entering {
|
||
return ast.WalkContinue
|
||
}
|
||
|
||
if !n.IsChildBlockOf(tree.Root, 1) {
|
||
return ast.WalkContinue
|
||
}
|
||
|
||
ret++
|
||
if n.ID == rootChild.ID {
|
||
return ast.WalkStop
|
||
}
|
||
return ast.WalkContinue
|
||
})
|
||
return
|
||
}
|
||
|
||
func GetBlocksIndexes(ids []string) (ret map[string]int) {
|
||
ret = map[string]int{}
|
||
if 1 > len(ids) {
|
||
return
|
||
}
|
||
|
||
tree, _ := LoadTreeByBlockID(ids[0])
|
||
if nil == tree {
|
||
return
|
||
}
|
||
|
||
idx := 0
|
||
nodesIndexes := map[string]int{}
|
||
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
|
||
if !entering {
|
||
return ast.WalkContinue
|
||
}
|
||
|
||
if !n.IsChildBlockOf(tree.Root, 1) {
|
||
if n.IsBlock() {
|
||
nodesIndexes[n.ID] = idx
|
||
}
|
||
return ast.WalkContinue
|
||
}
|
||
|
||
idx++
|
||
nodesIndexes[n.ID] = idx
|
||
return ast.WalkContinue
|
||
})
|
||
|
||
for _, id := range ids {
|
||
ret[id] = nodesIndexes[id]
|
||
}
|
||
return
|
||
}
|
||
|
||
type BlockPath struct {
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
Type string `json:"type"`
|
||
SubType string `json:"subType"`
|
||
Children []*BlockPath `json:"children"`
|
||
}
|
||
|
||
func BuildBlockBreadcrumb(id string, excludeTypes []string) (ret []*BlockPath, err error) {
|
||
ret = []*BlockPath{}
|
||
tree, err := LoadTreeByBlockID(id)
|
||
if nil == tree {
|
||
err = nil
|
||
return
|
||
}
|
||
node := treenode.GetNodeInTree(tree, id)
|
||
if nil == node {
|
||
return
|
||
}
|
||
|
||
ret = buildBlockBreadcrumb(node, excludeTypes, false)
|
||
return
|
||
}
|
||
|
||
func buildBlockBreadcrumb(node *ast.Node, excludeTypes []string, isEmbedBlock bool, headingMode ...int) (ret []*BlockPath) {
|
||
ret = []*BlockPath{}
|
||
if nil == node {
|
||
return
|
||
}
|
||
box := Conf.Box(node.Box)
|
||
if nil == box {
|
||
return
|
||
}
|
||
|
||
// 默认 headingMode 为 0
|
||
mode := 0
|
||
if len(headingMode) > 0 {
|
||
mode = headingMode[0]
|
||
}
|
||
|
||
headingLevel := 16
|
||
maxNameLen := 1024
|
||
var hPath string
|
||
baseBlock := treenode.GetBlockTreeRootByPath(node.Box, node.Path)
|
||
if nil != baseBlock {
|
||
hPath = baseBlock.HPath
|
||
}
|
||
for parent := node; nil != parent; parent = parent.Parent {
|
||
if "" == parent.ID {
|
||
continue
|
||
}
|
||
id := parent.ID
|
||
fc := treenode.FirstLeafBlock(parent)
|
||
|
||
name := parent.IALAttr("name")
|
||
if ast.NodeDocument == parent.Type {
|
||
name = box.Name + hPath
|
||
} else if ast.NodeAttributeView == parent.Type {
|
||
name, _ = av.GetAttributeViewName(parent.AttributeViewID)
|
||
} else {
|
||
if "" == name {
|
||
if ast.NodeListItem == parent.Type || ast.NodeList == parent.Type || ast.NodeSuperBlock == parent.Type || ast.NodeBlockquote == parent.Type {
|
||
name = gulu.Str.SubStr(renderBlockText(fc, excludeTypes, true), maxNameLen)
|
||
} else {
|
||
name = gulu.Str.SubStr(renderBlockText(parent, excludeTypes, true), maxNameLen)
|
||
}
|
||
}
|
||
if ast.NodeHeading == parent.Type {
|
||
headingLevel = parent.HeadingLevel
|
||
}
|
||
}
|
||
|
||
add := true
|
||
if ast.NodeList == parent.Type || ast.NodeSuperBlock == parent.Type || ast.NodeBlockquote == parent.Type {
|
||
add = false
|
||
if parent == node {
|
||
// https://github.com/siyuan-note/siyuan/issues/13141#issuecomment-2476789553
|
||
add = true
|
||
}
|
||
}
|
||
if ast.NodeParagraph == parent.Type && nil != parent.Parent && ast.NodeListItem == parent.Parent.Type && nil == parent.Next && (nil == parent.Previous || ast.NodeTaskListItemMarker == parent.Previous.Type) {
|
||
add = false
|
||
}
|
||
if ast.NodeListItem == parent.Type {
|
||
if "" == name {
|
||
name = gulu.Str.SubStr(renderBlockText(fc, excludeTypes, true), maxNameLen)
|
||
}
|
||
}
|
||
|
||
name = strings.ReplaceAll(name, editor.Caret, "")
|
||
name = util.UnescapeHTML(name)
|
||
name = util.EscapeHTML(name)
|
||
|
||
if !isEmbedBlock {
|
||
if parent == node {
|
||
name = ""
|
||
}
|
||
} else {
|
||
if ast.NodeDocument != parent.Type {
|
||
// 当headingMode=2（仅显示标题下方的块）且当前节点是标题时，保留标题名称
|
||
if 2 == mode && ast.NodeHeading == parent.Type && parent == node {
|
||
// 保留标题名称，不清空
|
||
} else {
|
||
// 在嵌入块中隐藏最后一个非文档路径的面包屑中的文本 Hide text in breadcrumb of last non-document path in embed block https://github.com/siyuan-note/siyuan/issues/13866
|
||
name = ""
|
||
}
|
||
}
|
||
}
|
||
|
||
if add {
|
||
ret = append([]*BlockPath{{
|
||
ID: id,
|
||
Name: name,
|
||
Type: parent.Type.String(),
|
||
SubType: treenode.SubTypeAbbr(parent),
|
||
}}, ret...)
|
||
}
|
||
|
||
for prev := parent.Previous; nil != prev; prev = prev.Previous {
|
||
b := prev
|
||
if ast.NodeSuperBlock == prev.Type {
|
||
// 超级块中包含标题块时下方块面包屑计算不正确 https://github.com/siyuan-note/siyuan/issues/6675
|
||
b = treenode.SuperBlockLastHeading(prev)
|
||
if nil == b {
|
||
// 超级块下方块被作为嵌入块时设置显示面包屑后不渲染 https://github.com/siyuan-note/siyuan/issues/6690
|
||
b = prev
|
||
}
|
||
}
|
||
|
||
if ast.NodeHeading == b.Type && headingLevel > b.HeadingLevel {
|
||
if b.ParentIs(ast.NodeListItem) {
|
||
// 标题在列表下时不显示 https://github.com/siyuan-note/siyuan/issues/13008
|
||
continue
|
||
}
|
||
|
||
name = gulu.Str.SubStr(renderBlockText(b, excludeTypes, true), maxNameLen)
|
||
name = util.UnescapeHTML(name)
|
||
name = util.EscapeHTML(name)
|
||
ret = append([]*BlockPath{{
|
||
ID: b.ID,
|
||
Name: name,
|
||
Type: b.Type.String(),
|
||
SubType: treenode.SubTypeAbbr(b),
|
||
}}, ret...)
|
||
headingLevel = b.HeadingLevel
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func buildBacklinkListItemRefs(refDefs []*RefDefs) (originalRefBlockIDs map[string]string) {
|
||
originalRefBlockIDs = map[string]string{}
|
||
|
||
var refIDs []string
|
||
for _, refDef := range refDefs {
|
||
refIDs = append(refIDs, refDef.RefID)
|
||
}
|
||
sqlRefBlocks := sql.GetBlocks(refIDs)
|
||
refBlocks := fromSQLBlocks(&sqlRefBlocks, "", 12)
|
||
|
||
parentRefParagraphs := map[string]*Block{}
|
||
var paragraphParentIDs []string
|
||
for _, ref := range refBlocks {
|
||
if nil != ref && "NodeParagraph" == ref.Type {
|
||
parentRefParagraphs[ref.ParentID] = ref
|
||
paragraphParentIDs = append(paragraphParentIDs, ref.ParentID)
|
||
}
|
||
}
|
||
sqlParagraphParents := sql.GetBlocks(paragraphParentIDs)
|
||
paragraphParents := fromSQLBlocks(&sqlParagraphParents, "", 12)
|
||
|
||
luteEngine := util.NewLute()
|
||
processedParagraphs := hashset.New()
|
||
for _, parent := range paragraphParents {
|
||
if nil == parent {
|
||
continue
|
||
}
|
||
|
||
if "NodeListItem" == parent.Type || "NodeBlockquote" == parent.Type || "NodeSuperBlock" == parent.Type {
|
||
refBlock := parentRefParagraphs[parent.ID]
|
||
if nil == refBlock {
|
||
continue
|
||
}
|
||
|
||
paragraphUseParentLi := true
|
||
if "NodeListItem" == parent.Type && parent.FContent != refBlock.Content {
|
||
if inlineTree := parse.Inline("", []byte(refBlock.Markdown), luteEngine.ParseOptions); nil != inlineTree {
|
||
for c := inlineTree.Root.FirstChild.FirstChild; c != nil; c = c.Next {
|
||
if treenode.IsBlockRef(c) {
|
||
continue
|
||
}
|
||
|
||
if "" != strings.TrimSpace(c.Text()) {
|
||
paragraphUseParentLi = false
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if paragraphUseParentLi {
|
||
for _, refDef := range refDefs {
|
||
if refDef.RefID == refBlock.ID {
|
||
refDef.RefID = parent.ID
|
||
break
|
||
}
|
||
}
|
||
processedParagraphs.Add(parent.ID)
|
||
}
|
||
|
||
originalRefBlockIDs[parent.ID] = refBlock.ID
|
||
}
|
||
}
|
||
return
|
||
}
|