mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-26 06:07:28 +02:00
162 lines
4.6 KiB
Go
162 lines
4.6 KiB
Go
|
package goquery
|
||
|
|
||
|
import (
|
||
|
"bytes"
|
||
|
|
||
|
"golang.org/x/net/html"
|
||
|
)
|
||
|
|
||
|
// used to determine if a set (map[*html.Node]bool) should be used
|
||
|
// instead of iterating over a slice. The set uses more memory and
|
||
|
// is slower than slice iteration for small N.
|
||
|
const minNodesForSet = 1000
|
||
|
|
||
|
var nodeNames = []string{
|
||
|
html.ErrorNode: "#error",
|
||
|
html.TextNode: "#text",
|
||
|
html.DocumentNode: "#document",
|
||
|
html.CommentNode: "#comment",
|
||
|
}
|
||
|
|
||
|
// NodeName returns the node name of the first element in the selection.
|
||
|
// It tries to behave in a similar way as the DOM's nodeName property
|
||
|
// (https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeName).
|
||
|
//
|
||
|
// Go's net/html package defines the following node types, listed with
|
||
|
// the corresponding returned value from this function:
|
||
|
//
|
||
|
// ErrorNode : #error
|
||
|
// TextNode : #text
|
||
|
// DocumentNode : #document
|
||
|
// ElementNode : the element's tag name
|
||
|
// CommentNode : #comment
|
||
|
// DoctypeNode : the name of the document type
|
||
|
//
|
||
|
func NodeName(s *Selection) string {
|
||
|
if s.Length() == 0 {
|
||
|
return ""
|
||
|
}
|
||
|
switch n := s.Get(0); n.Type {
|
||
|
case html.ElementNode, html.DoctypeNode:
|
||
|
return n.Data
|
||
|
default:
|
||
|
if n.Type >= 0 && int(n.Type) < len(nodeNames) {
|
||
|
return nodeNames[n.Type]
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// OuterHtml returns the outer HTML rendering of the first item in
|
||
|
// the selection - that is, the HTML including the first element's
|
||
|
// tag and attributes.
|
||
|
//
|
||
|
// Unlike InnerHtml, this is a function and not a method on the Selection,
|
||
|
// because this is not a jQuery method (in javascript-land, this is
|
||
|
// a property provided by the DOM).
|
||
|
func OuterHtml(s *Selection) (string, error) {
|
||
|
var buf bytes.Buffer
|
||
|
|
||
|
if s.Length() == 0 {
|
||
|
return "", nil
|
||
|
}
|
||
|
n := s.Get(0)
|
||
|
if err := html.Render(&buf, n); err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
return buf.String(), nil
|
||
|
}
|
||
|
|
||
|
// Loop through all container nodes to search for the target node.
|
||
|
func sliceContains(container []*html.Node, contained *html.Node) bool {
|
||
|
for _, n := range container {
|
||
|
if nodeContains(n, contained) {
|
||
|
return true
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// Checks if the contained node is within the container node.
|
||
|
func nodeContains(container *html.Node, contained *html.Node) bool {
|
||
|
// Check if the parent of the contained node is the container node, traversing
|
||
|
// upward until the top is reached, or the container is found.
|
||
|
for contained = contained.Parent; contained != nil; contained = contained.Parent {
|
||
|
if container == contained {
|
||
|
return true
|
||
|
}
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// Checks if the target node is in the slice of nodes.
|
||
|
func isInSlice(slice []*html.Node, node *html.Node) bool {
|
||
|
return indexInSlice(slice, node) > -1
|
||
|
}
|
||
|
|
||
|
// Returns the index of the target node in the slice, or -1.
|
||
|
func indexInSlice(slice []*html.Node, node *html.Node) int {
|
||
|
if node != nil {
|
||
|
for i, n := range slice {
|
||
|
if n == node {
|
||
|
return i
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return -1
|
||
|
}
|
||
|
|
||
|
// Appends the new nodes to the target slice, making sure no duplicate is added.
|
||
|
// There is no check to the original state of the target slice, so it may still
|
||
|
// contain duplicates. The target slice is returned because append() may create
|
||
|
// a new underlying array. If targetSet is nil, a local set is created with the
|
||
|
// target if len(target) + len(nodes) is greater than minNodesForSet.
|
||
|
func appendWithoutDuplicates(target []*html.Node, nodes []*html.Node, targetSet map[*html.Node]bool) []*html.Node {
|
||
|
// if there are not that many nodes, don't use the map, faster to just use nested loops
|
||
|
// (unless a non-nil targetSet is passed, in which case the caller knows better).
|
||
|
if targetSet == nil && len(target)+len(nodes) < minNodesForSet {
|
||
|
for _, n := range nodes {
|
||
|
if !isInSlice(target, n) {
|
||
|
target = append(target, n)
|
||
|
}
|
||
|
}
|
||
|
return target
|
||
|
}
|
||
|
|
||
|
// if a targetSet is passed, then assume it is reliable, otherwise create one
|
||
|
// and initialize it with the current target contents.
|
||
|
if targetSet == nil {
|
||
|
targetSet = make(map[*html.Node]bool, len(target))
|
||
|
for _, n := range target {
|
||
|
targetSet[n] = true
|
||
|
}
|
||
|
}
|
||
|
for _, n := range nodes {
|
||
|
if !targetSet[n] {
|
||
|
target = append(target, n)
|
||
|
targetSet[n] = true
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return target
|
||
|
}
|
||
|
|
||
|
// Loop through a selection, returning only those nodes that pass the predicate
|
||
|
// function.
|
||
|
func grep(sel *Selection, predicate func(i int, s *Selection) bool) (result []*html.Node) {
|
||
|
for i, n := range sel.Nodes {
|
||
|
if predicate(i, newSingleSelection(n, sel.document)) {
|
||
|
result = append(result, n)
|
||
|
}
|
||
|
}
|
||
|
return result
|
||
|
}
|
||
|
|
||
|
// Creates a new Selection object based on the specified nodes, and keeps the
|
||
|
// source Selection object on the stack (linked list).
|
||
|
func pushStack(fromSel *Selection, nodes []*html.Node) *Selection {
|
||
|
result := &Selection{nodes, fromSel.document, fromSel}
|
||
|
return result
|
||
|
}
|