680 lines
21 KiB
Go
680 lines
21 KiB
Go
package goquery
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"golang.org/x/net/html"
|
|
)
|
|
|
|
// After applies the selector from the root document and inserts the matched elements
|
|
// after the elements in the set of matched elements.
|
|
//
|
|
// If one of the matched elements in the selection is not currently in the
|
|
// document, it's impossible to insert nodes after it, so it will be ignored.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) After(selector string) *Selection {
|
|
return s.AfterMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// AfterMatcher applies the matcher from the root document and inserts the matched elements
|
|
// after the elements in the set of matched elements.
|
|
//
|
|
// If one of the matched elements in the selection is not currently in the
|
|
// document, it's impossible to insert nodes after it, so it will be ignored.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) AfterMatcher(m Matcher) *Selection {
|
|
return s.AfterNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// AfterSelection inserts the elements in the selection after each element in the set of matched
|
|
// elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) AfterSelection(sel *Selection) *Selection {
|
|
return s.AfterNodes(sel.Nodes...)
|
|
}
|
|
|
|
// AfterHtml parses the html and inserts it after the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) AfterHtml(htmlStr string) *Selection {
|
|
return s.eachNodeHtml(htmlStr, true, func(node *html.Node, nodes []*html.Node) {
|
|
nextSibling := node.NextSibling
|
|
for _, n := range nodes {
|
|
if node.Parent != nil {
|
|
node.Parent.InsertBefore(n, nextSibling)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// AfterNodes inserts the nodes after each element in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) AfterNodes(ns ...*html.Node) *Selection {
|
|
return s.manipulateNodes(ns, true, func(sn *html.Node, n *html.Node) {
|
|
if sn.Parent != nil {
|
|
sn.Parent.InsertBefore(n, sn.NextSibling)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Append appends the elements specified by the selector to the end of each element
|
|
// in the set of matched elements, following those rules:
|
|
//
|
|
// 1) The selector is applied to the root document.
|
|
//
|
|
// 2) Elements that are part of the document will be moved to the new location.
|
|
//
|
|
// 3) If there are multiple locations to append to, cloned nodes will be
|
|
// appended to all target locations except the last one, which will be moved
|
|
// as noted in (2).
|
|
func (s *Selection) Append(selector string) *Selection {
|
|
return s.AppendMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// AppendMatcher appends the elements specified by the matcher to the end of each element
|
|
// in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) AppendMatcher(m Matcher) *Selection {
|
|
return s.AppendNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// AppendSelection appends the elements in the selection to the end of each element
|
|
// in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) AppendSelection(sel *Selection) *Selection {
|
|
return s.AppendNodes(sel.Nodes...)
|
|
}
|
|
|
|
// AppendHtml parses the html and appends it to the set of matched elements.
|
|
func (s *Selection) AppendHtml(htmlStr string) *Selection {
|
|
return s.eachNodeHtml(htmlStr, false, func(node *html.Node, nodes []*html.Node) {
|
|
for _, n := range nodes {
|
|
node.AppendChild(n)
|
|
}
|
|
})
|
|
}
|
|
|
|
// AppendNodes appends the specified nodes to each node in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) AppendNodes(ns ...*html.Node) *Selection {
|
|
return s.manipulateNodes(ns, false, func(sn *html.Node, n *html.Node) {
|
|
sn.AppendChild(n)
|
|
})
|
|
}
|
|
|
|
// Before inserts the matched elements before each element in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) Before(selector string) *Selection {
|
|
return s.BeforeMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// BeforeMatcher inserts the matched elements before each element in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) BeforeMatcher(m Matcher) *Selection {
|
|
return s.BeforeNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// BeforeSelection inserts the elements in the selection before each element in the set of matched
|
|
// elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) BeforeSelection(sel *Selection) *Selection {
|
|
return s.BeforeNodes(sel.Nodes...)
|
|
}
|
|
|
|
// BeforeHtml parses the html and inserts it before the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) BeforeHtml(htmlStr string) *Selection {
|
|
return s.eachNodeHtml(htmlStr, true, func(node *html.Node, nodes []*html.Node) {
|
|
for _, n := range nodes {
|
|
if node.Parent != nil {
|
|
node.Parent.InsertBefore(n, node)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
// BeforeNodes inserts the nodes before each element in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) BeforeNodes(ns ...*html.Node) *Selection {
|
|
return s.manipulateNodes(ns, false, func(sn *html.Node, n *html.Node) {
|
|
if sn.Parent != nil {
|
|
sn.Parent.InsertBefore(n, sn)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Clone creates a deep copy of the set of matched nodes. The new nodes will not be
|
|
// attached to the document.
|
|
func (s *Selection) Clone() *Selection {
|
|
ns := newEmptySelection(s.document)
|
|
ns.Nodes = cloneNodes(s.Nodes)
|
|
return ns
|
|
}
|
|
|
|
// Empty removes all children nodes from the set of matched elements.
|
|
// It returns the children nodes in a new Selection.
|
|
func (s *Selection) Empty() *Selection {
|
|
var nodes []*html.Node
|
|
|
|
for _, n := range s.Nodes {
|
|
for c := n.FirstChild; c != nil; c = n.FirstChild {
|
|
n.RemoveChild(c)
|
|
nodes = append(nodes, c)
|
|
}
|
|
}
|
|
|
|
return pushStack(s, nodes)
|
|
}
|
|
|
|
// Prepend prepends the elements specified by the selector to each element in
|
|
// the set of matched elements, following the same rules as Append.
|
|
func (s *Selection) Prepend(selector string) *Selection {
|
|
return s.PrependMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// PrependMatcher prepends the elements specified by the matcher to each
|
|
// element in the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) PrependMatcher(m Matcher) *Selection {
|
|
return s.PrependNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// PrependSelection prepends the elements in the selection to each element in
|
|
// the set of matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) PrependSelection(sel *Selection) *Selection {
|
|
return s.PrependNodes(sel.Nodes...)
|
|
}
|
|
|
|
// PrependHtml parses the html and prepends it to the set of matched elements.
|
|
func (s *Selection) PrependHtml(htmlStr string) *Selection {
|
|
return s.eachNodeHtml(htmlStr, false, func(node *html.Node, nodes []*html.Node) {
|
|
firstChild := node.FirstChild
|
|
for _, n := range nodes {
|
|
node.InsertBefore(n, firstChild)
|
|
}
|
|
})
|
|
}
|
|
|
|
// PrependNodes prepends the specified nodes to each node in the set of
|
|
// matched elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) PrependNodes(ns ...*html.Node) *Selection {
|
|
return s.manipulateNodes(ns, true, func(sn *html.Node, n *html.Node) {
|
|
// sn.FirstChild may be nil, in which case this functions like
|
|
// sn.AppendChild()
|
|
sn.InsertBefore(n, sn.FirstChild)
|
|
})
|
|
}
|
|
|
|
// Remove removes the set of matched elements from the document.
|
|
// It returns the same selection, now consisting of nodes not in the document.
|
|
func (s *Selection) Remove() *Selection {
|
|
for _, n := range s.Nodes {
|
|
if n.Parent != nil {
|
|
n.Parent.RemoveChild(n)
|
|
}
|
|
}
|
|
|
|
return s
|
|
}
|
|
|
|
// RemoveFiltered removes from the current set of matched elements those that
|
|
// match the selector filter. It returns the Selection of removed nodes.
|
|
//
|
|
// For example if the selection s contains "<h1>", "<h2>" and "<h3>"
|
|
// and s.RemoveFiltered("h2") is called, only the "<h2>" node is removed
|
|
// (and returned), while "<h1>" and "<h3>" are kept in the document.
|
|
func (s *Selection) RemoveFiltered(selector string) *Selection {
|
|
return s.RemoveMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// RemoveMatcher removes from the current set of matched elements those that
|
|
// match the Matcher filter. It returns the Selection of removed nodes.
|
|
// See RemoveFiltered for additional information.
|
|
func (s *Selection) RemoveMatcher(m Matcher) *Selection {
|
|
return s.FilterMatcher(m).Remove()
|
|
}
|
|
|
|
// ReplaceWith replaces each element in the set of matched elements with the
|
|
// nodes matched by the given selector.
|
|
// It returns the removed elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) ReplaceWith(selector string) *Selection {
|
|
return s.ReplaceWithMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// ReplaceWithMatcher replaces each element in the set of matched elements with
|
|
// the nodes matched by the given Matcher.
|
|
// It returns the removed elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) ReplaceWithMatcher(m Matcher) *Selection {
|
|
return s.ReplaceWithNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// ReplaceWithSelection replaces each element in the set of matched elements with
|
|
// the nodes from the given Selection.
|
|
// It returns the removed elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) ReplaceWithSelection(sel *Selection) *Selection {
|
|
return s.ReplaceWithNodes(sel.Nodes...)
|
|
}
|
|
|
|
// ReplaceWithHtml replaces each element in the set of matched elements with
|
|
// the parsed HTML.
|
|
// It returns the removed elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) ReplaceWithHtml(htmlStr string) *Selection {
|
|
s.eachNodeHtml(htmlStr, true, func(node *html.Node, nodes []*html.Node) {
|
|
nextSibling := node.NextSibling
|
|
for _, n := range nodes {
|
|
if node.Parent != nil {
|
|
node.Parent.InsertBefore(n, nextSibling)
|
|
}
|
|
}
|
|
})
|
|
return s.Remove()
|
|
}
|
|
|
|
// ReplaceWithNodes replaces each element in the set of matched elements with
|
|
// the given nodes.
|
|
// It returns the removed elements.
|
|
//
|
|
// This follows the same rules as Selection.Append.
|
|
func (s *Selection) ReplaceWithNodes(ns ...*html.Node) *Selection {
|
|
s.AfterNodes(ns...)
|
|
return s.Remove()
|
|
}
|
|
|
|
// SetHtml sets the html content of each element in the selection to
|
|
// specified html string.
|
|
func (s *Selection) SetHtml(htmlStr string) *Selection {
|
|
for _, context := range s.Nodes {
|
|
for c := context.FirstChild; c != nil; c = context.FirstChild {
|
|
context.RemoveChild(c)
|
|
}
|
|
}
|
|
return s.eachNodeHtml(htmlStr, false, func(node *html.Node, nodes []*html.Node) {
|
|
for _, n := range nodes {
|
|
node.AppendChild(n)
|
|
}
|
|
})
|
|
}
|
|
|
|
// SetText sets the content of each element in the selection to specified content.
|
|
// The provided text string is escaped.
|
|
func (s *Selection) SetText(text string) *Selection {
|
|
return s.SetHtml(html.EscapeString(text))
|
|
}
|
|
|
|
// Unwrap removes the parents of the set of matched elements, leaving the matched
|
|
// elements (and their siblings, if any) in their place.
|
|
// It returns the original selection.
|
|
func (s *Selection) Unwrap() *Selection {
|
|
s.Parent().Each(func(i int, ss *Selection) {
|
|
// For some reason, jquery allows unwrap to remove the <head> element, so
|
|
// allowing it here too. Same for <html>. Why it allows those elements to
|
|
// be unwrapped while not allowing body is a mystery to me.
|
|
if ss.Nodes[0].Data != "body" {
|
|
ss.ReplaceWithSelection(ss.Contents())
|
|
}
|
|
})
|
|
|
|
return s
|
|
}
|
|
|
|
// Wrap wraps each element in the set of matched elements inside the first
|
|
// element matched by the given selector. The matched child is cloned before
|
|
// being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) Wrap(selector string) *Selection {
|
|
return s.WrapMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// WrapMatcher wraps each element in the set of matched elements inside the
|
|
// first element matched by the given matcher. The matched child is cloned
|
|
// before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapMatcher(m Matcher) *Selection {
|
|
return s.wrapNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// WrapSelection wraps each element in the set of matched elements inside the
|
|
// first element in the given Selection. The element is cloned before being
|
|
// inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapSelection(sel *Selection) *Selection {
|
|
return s.wrapNodes(sel.Nodes...)
|
|
}
|
|
|
|
// WrapHtml wraps each element in the set of matched elements inside the inner-
|
|
// most child of the given HTML.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapHtml(htmlStr string) *Selection {
|
|
nodesMap := make(map[string][]*html.Node)
|
|
for _, context := range s.Nodes {
|
|
var parent *html.Node
|
|
if context.Parent != nil {
|
|
parent = context.Parent
|
|
} else {
|
|
parent = &html.Node{Type: html.ElementNode}
|
|
}
|
|
nodes, found := nodesMap[nodeName(parent)]
|
|
if !found {
|
|
nodes = parseHtmlWithContext(htmlStr, parent)
|
|
nodesMap[nodeName(parent)] = nodes
|
|
}
|
|
newSingleSelection(context, s.document).wrapAllNodes(cloneNodes(nodes)...)
|
|
}
|
|
return s
|
|
}
|
|
|
|
// WrapNode wraps each element in the set of matched elements inside the inner-
|
|
// most child of the given node. The given node is copied before being inserted
|
|
// into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapNode(n *html.Node) *Selection {
|
|
return s.wrapNodes(n)
|
|
}
|
|
|
|
func (s *Selection) wrapNodes(ns ...*html.Node) *Selection {
|
|
s.Each(func(i int, ss *Selection) {
|
|
ss.wrapAllNodes(ns...)
|
|
})
|
|
|
|
return s
|
|
}
|
|
|
|
// WrapAll wraps a single HTML structure, matched by the given selector, around
|
|
// all elements in the set of matched elements. The matched child is cloned
|
|
// before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapAll(selector string) *Selection {
|
|
return s.WrapAllMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// WrapAllMatcher wraps a single HTML structure, matched by the given Matcher,
|
|
// around all elements in the set of matched elements. The matched child is
|
|
// cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapAllMatcher(m Matcher) *Selection {
|
|
return s.wrapAllNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// WrapAllSelection wraps a single HTML structure, the first node of the given
|
|
// Selection, around all elements in the set of matched elements. The matched
|
|
// child is cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapAllSelection(sel *Selection) *Selection {
|
|
return s.wrapAllNodes(sel.Nodes...)
|
|
}
|
|
|
|
// WrapAllHtml wraps the given HTML structure around all elements in the set of
|
|
// matched elements. The matched child is cloned before being inserted into the
|
|
// document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapAllHtml(htmlStr string) *Selection {
|
|
var context *html.Node
|
|
var nodes []*html.Node
|
|
if len(s.Nodes) > 0 {
|
|
context = s.Nodes[0]
|
|
if context.Parent != nil {
|
|
nodes = parseHtmlWithContext(htmlStr, context)
|
|
} else {
|
|
nodes = parseHtml(htmlStr)
|
|
}
|
|
}
|
|
return s.wrapAllNodes(nodes...)
|
|
}
|
|
|
|
func (s *Selection) wrapAllNodes(ns ...*html.Node) *Selection {
|
|
if len(ns) > 0 {
|
|
return s.WrapAllNode(ns[0])
|
|
}
|
|
return s
|
|
}
|
|
|
|
// WrapAllNode wraps the given node around the first element in the Selection,
|
|
// making all other nodes in the Selection children of the given node. The node
|
|
// is cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapAllNode(n *html.Node) *Selection {
|
|
if s.Size() == 0 {
|
|
return s
|
|
}
|
|
|
|
wrap := cloneNode(n)
|
|
|
|
first := s.Nodes[0]
|
|
if first.Parent != nil {
|
|
first.Parent.InsertBefore(wrap, first)
|
|
first.Parent.RemoveChild(first)
|
|
}
|
|
|
|
for c := getFirstChildEl(wrap); c != nil; c = getFirstChildEl(wrap) {
|
|
wrap = c
|
|
}
|
|
|
|
newSingleSelection(wrap, s.document).AppendSelection(s)
|
|
|
|
return s
|
|
}
|
|
|
|
// WrapInner wraps an HTML structure, matched by the given selector, around the
|
|
// content of element in the set of matched elements. The matched child is
|
|
// cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapInner(selector string) *Selection {
|
|
return s.WrapInnerMatcher(compileMatcher(selector))
|
|
}
|
|
|
|
// WrapInnerMatcher wraps an HTML structure, matched by the given selector,
|
|
// around the content of element in the set of matched elements. The matched
|
|
// child is cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapInnerMatcher(m Matcher) *Selection {
|
|
return s.wrapInnerNodes(m.MatchAll(s.document.rootNode)...)
|
|
}
|
|
|
|
// WrapInnerSelection wraps an HTML structure, matched by the given selector,
|
|
// around the content of element in the set of matched elements. The matched
|
|
// child is cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapInnerSelection(sel *Selection) *Selection {
|
|
return s.wrapInnerNodes(sel.Nodes...)
|
|
}
|
|
|
|
// WrapInnerHtml wraps an HTML structure, matched by the given selector, around
|
|
// the content of element in the set of matched elements. The matched child is
|
|
// cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapInnerHtml(htmlStr string) *Selection {
|
|
nodesMap := make(map[string][]*html.Node)
|
|
for _, context := range s.Nodes {
|
|
nodes, found := nodesMap[nodeName(context)]
|
|
if !found {
|
|
nodes = parseHtmlWithContext(htmlStr, context)
|
|
nodesMap[nodeName(context)] = nodes
|
|
}
|
|
newSingleSelection(context, s.document).wrapInnerNodes(cloneNodes(nodes)...)
|
|
}
|
|
return s
|
|
}
|
|
|
|
// WrapInnerNode wraps an HTML structure, matched by the given selector, around
|
|
// the content of element in the set of matched elements. The matched child is
|
|
// cloned before being inserted into the document.
|
|
//
|
|
// It returns the original set of elements.
|
|
func (s *Selection) WrapInnerNode(n *html.Node) *Selection {
|
|
return s.wrapInnerNodes(n)
|
|
}
|
|
|
|
func (s *Selection) wrapInnerNodes(ns ...*html.Node) *Selection {
|
|
if len(ns) == 0 {
|
|
return s
|
|
}
|
|
|
|
s.Each(func(i int, s *Selection) {
|
|
contents := s.Contents()
|
|
|
|
if contents.Size() > 0 {
|
|
contents.wrapAllNodes(ns...)
|
|
} else {
|
|
s.AppendNodes(cloneNode(ns[0]))
|
|
}
|
|
})
|
|
|
|
return s
|
|
}
|
|
|
|
func parseHtml(h string) []*html.Node {
|
|
// Errors are only returned when the io.Reader returns any error besides
|
|
// EOF, but strings.Reader never will
|
|
nodes, err := html.ParseFragment(strings.NewReader(h), &html.Node{Type: html.ElementNode})
|
|
if err != nil {
|
|
panic("goquery: failed to parse HTML: " + err.Error())
|
|
}
|
|
return nodes
|
|
}
|
|
|
|
func parseHtmlWithContext(h string, context *html.Node) []*html.Node {
|
|
// Errors are only returned when the io.Reader returns any error besides
|
|
// EOF, but strings.Reader never will
|
|
nodes, err := html.ParseFragment(strings.NewReader(h), context)
|
|
if err != nil {
|
|
panic("goquery: failed to parse HTML: " + err.Error())
|
|
}
|
|
return nodes
|
|
}
|
|
|
|
// Get the first child that is an ElementNode
|
|
func getFirstChildEl(n *html.Node) *html.Node {
|
|
c := n.FirstChild
|
|
for c != nil && c.Type != html.ElementNode {
|
|
c = c.NextSibling
|
|
}
|
|
return c
|
|
}
|
|
|
|
// Deep copy a slice of nodes.
|
|
func cloneNodes(ns []*html.Node) []*html.Node {
|
|
cns := make([]*html.Node, 0, len(ns))
|
|
|
|
for _, n := range ns {
|
|
cns = append(cns, cloneNode(n))
|
|
}
|
|
|
|
return cns
|
|
}
|
|
|
|
// Deep copy a node. The new node has clones of all the original node's
|
|
// children but none of its parents or siblings.
|
|
func cloneNode(n *html.Node) *html.Node {
|
|
nn := &html.Node{
|
|
Type: n.Type,
|
|
DataAtom: n.DataAtom,
|
|
Data: n.Data,
|
|
Attr: make([]html.Attribute, len(n.Attr)),
|
|
}
|
|
|
|
copy(nn.Attr, n.Attr)
|
|
for c := n.FirstChild; c != nil; c = c.NextSibling {
|
|
nn.AppendChild(cloneNode(c))
|
|
}
|
|
|
|
return nn
|
|
}
|
|
|
|
func (s *Selection) manipulateNodes(ns []*html.Node, reverse bool,
|
|
f func(sn *html.Node, n *html.Node)) *Selection {
|
|
|
|
lasti := s.Size() - 1
|
|
|
|
// net.Html doesn't provide document fragments for insertion, so to get
|
|
// things in the correct order with After() and Prepend(), the callback
|
|
// needs to be called on the reverse of the nodes.
|
|
if reverse {
|
|
for i, j := 0, len(ns)-1; i < j; i, j = i+1, j-1 {
|
|
ns[i], ns[j] = ns[j], ns[i]
|
|
}
|
|
}
|
|
|
|
for i, sn := range s.Nodes {
|
|
for _, n := range ns {
|
|
if i != lasti {
|
|
f(sn, cloneNode(n))
|
|
} else {
|
|
if n.Parent != nil {
|
|
n.Parent.RemoveChild(n)
|
|
}
|
|
f(sn, n)
|
|
}
|
|
}
|
|
}
|
|
|
|
return s
|
|
}
|
|
|
|
// eachNodeHtml parses the given html string and inserts the resulting nodes in the dom with the mergeFn.
|
|
// The parsed nodes are inserted for each element of the selection.
|
|
// isParent can be used to indicate that the elements of the selection should be treated as the parent for the parsed html.
|
|
// A cache is used to avoid parsing the html multiple times should the elements of the selection result in the same context.
|
|
func (s *Selection) eachNodeHtml(htmlStr string, isParent bool, mergeFn func(n *html.Node, nodes []*html.Node)) *Selection {
|
|
// cache to avoid parsing the html for the same context multiple times
|
|
nodeCache := make(map[string][]*html.Node)
|
|
var context *html.Node
|
|
for _, n := range s.Nodes {
|
|
if isParent {
|
|
context = n.Parent
|
|
} else {
|
|
if n.Type != html.ElementNode {
|
|
continue
|
|
}
|
|
context = n
|
|
}
|
|
if context != nil {
|
|
nodes, found := nodeCache[nodeName(context)]
|
|
if !found {
|
|
nodes = parseHtmlWithContext(htmlStr, context)
|
|
nodeCache[nodeName(context)] = nodes
|
|
}
|
|
mergeFn(n, cloneNodes(nodes))
|
|
}
|
|
}
|
|
return s
|
|
}
|