github.com/Kindred87/Obsidian@v0.0.0-20210809203756-86936424b848/retrieval/html/search.go

package html

import (
	"errors"
	"os"
	"strconv"

	"github.com/Kindred87/Obsidian/datasource"
	"github.com/PuerkitoBio/goquery"
	"golang.org/x/net/html"
)

/*
CollectionSiblings identifies arbitrary collections of HTML nodes from a datasource and
returns the contents of both the identified collections and their inferred siblings.

An arbitrary collection of nodes could be [b, a, d] from a table organized as [a, b, c, d].

Furthermore, with three collections of nodes in tables sharing parent p...

 p
 |> [a1, b1, c1, d1]
 |> [a2, b2, c2, c2]
 |> [a3, b3, c3, d3]

... and the two arbitrary collections are given...
 [b1, a1, d1]
 [b2, a2, d2]

...the values returned will be:
 [b1, a1, d1]
 [b2, a2, d2]
 [b3, a3, d3]

Had the third table not been the child of p, its nodes would not have been inferred as a sibling.

Each searchGroups subarray should contain a group of values expected to be within a shared structure, such as a table or table row.

Value order as given will be maintained, regardless of how the associated nodes are organized in the datasource.
*/
func CollectionSiblings(alias string, searchGroups [][]string) ([]NodeList, error) {
	if len(searchGroups) < 2 {
		return nil, errors.New("Only " + strconv.Itoa(len(searchGroups)) +
			" search groups were provided")
	}

	result, path, err := datasource.Find(alias)
	if err != nil {
		return nil, err
	} else if !result {
		return nil, errors.New("Could not locate datasource by the alias of " + alias)
	}

	fi, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	sel, err := findNodeGroups(fi, searchGroups)
	if err != nil {
		return nil, err
	}

	routes, err := nodeGroupRouting(sel)
	if err != nil {
		return nil, err
	}

	nList, err := getSiblingContents(routes.Grandparent.FirstChild, routes, []NodeList{})
	if err != nil {
		return nil, err
	}
	return nList, nil
}

// findNodeGroups returns HTML nodes containing the given values.
//
// The backing nodes of the returned selections are not shared between calls.
func findNodeGroups(fi *os.File, toFind [][]string) (selections [][]goquery.Selection, err error) {
	doc, err := goquery.NewDocumentFromReader(fi)
	if err != nil {
		return nil, err
	}

	// Reset the read position in case the file was previously read.
	if _, err := fi.Seek(0, 0); err != nil {
		return nil, err
	}

	for _, t := range toFind {
		if result, err := selectionsContaining(doc, t); err != nil {
			// Result is ignored in order to make it abundantly clear that
			// the user's query could not be satisfied in full.
			return nil, err
		} else {
			selections = append(selections, result)
		}
	}

	return selections, nil
}

// selectionsContaining retrieves selections with data matching values within toFind.
// If a value within toFind is not found, an error is returned in addition to the selections
// for all values that could be found.
func selectionsContaining(doc *goquery.Document, toFind []string) ([]goquery.Selection, error) {
	var selections []goquery.Selection

	found := make(map[string]bool)

	for _, val := range toFind {
		doc.Find("*:contains('" + val + "')").Each(func(i int, s *goquery.Selection) {
			if len(s.Nodes) > 0 && s.Nodes[0].Data == val && !found[val] {
				selections = append(selections, *s)
				found[val] = true
			}
		})

	}

	for _, v := range toFind {
		if !found[v] {
			return selections, errors.New("Could not find value: " + v)
		}
	}

	return selections, nil
}

// getSiblingContents selectively returns the contents of all sibling node collections within a layer.
// Content selection is determined by the given routeGroup.
//
// The initial call should provide the first node of the layer.  This will usually be the
// first child of a grandparent node.
func getSiblingContents(curr *html.Node, rg routeGroup, nodes []NodeList) ([]NodeList, error) {
	if curr == nil {
		return nodes, nil
	}

	if found, class := classAttributeFrom(curr.Attr); found && class == rg.ParentClass {
		children, err := listChildrenOf(curr, rg)
		if err != nil {
			return nodes, err
		}

		nodes = append(nodes, children)

	}
	return getSiblingContents(curr.NextSibling, rg, nodes)
}

// listChildrenOf returns children routed to from the given parent.
func listChildrenOf(parent *html.Node, rg routeGroup) (nList NodeList, err error) {
	children, err := rg.childrenOf(parent)
	if err != nil {
		return nList, err
	}

	for i, child := range children {
		if child == nil {
			missingNode := Node{
				ID:   i,
				Data: "N/A",
			}
			nList.Nodes = append(nList.Nodes, missingNode)
		} else {
			nList.Nodes = append(nList.Nodes, nodeFromNode(i, child))
		}
	}

	return nList, nil
}

// findNodes identifies nodes containing any of the values within toFind.
func findNodes(fi *os.File, toFind []string) ([]goquery.Selection, error) {
	doc, err := goquery.NewDocumentFromReader(fi)
	if err != nil {
		return nil, err
	}

	// Reset the read position in case the file was previously read.
	if _, err := fi.Seek(0, 0); err != nil {
		return nil, err
	}

	sel, err := selectionsContaining(doc, toFind)
	if err != nil {
		return nil, err
	}

	return sel, nil
}