fix doc for build instruction of exp package

README.md

@@ -8,7 +8,11 @@ Syntax-wise, it is as close as possible to jQuery, with the same function names
 
 ## Installation
 
-Since this library (and cascadia) depends on the experimental branch, this package must be installed first. Both GoQuery and Cascadia expect to find the experimental library with the `"exp/html"` import statement. To install it at this location, please [follow this guide][wikiexp].
+Since this library (and cascadia) depends on the experimental branch, this package must be installed first. Both GoQuery and Cascadia expect to find the experimental library with the `"exp/html"` import statement. To install it at this location, there's [this guide][wikiexp], but since late December 2012, Go tip has evolved and `"exp/html"` won't build with Go1.0.3. So the last valid revision that will build with Go1 is `d9ff34d481bc`. Just replace the second step in [the guide][wikiexp] with this command:
+
+    hg clone -r d9ff34d481bc https://code.google.com/p/go go-exp
+
+The rest of the guide can be followed as-is (note that you can build just the `exp/html` package, you don't have to build `exp/...`).
 
 Once this is done, install GoQuery:
 
@@ -24,8 +28,9 @@ To run benchmarks, run this command in goquery's source directory:
 
 ## Changelog
 
-*    **v0.1.0** : Initial release. See [TODOs](#a1) for a list of upcoming features.
+*    **v0.2.0** : Add support for negative indices in Slice(). **BREAKING CHANGE** `Document.Root` is removed, `Document` is now a `Selection` itself (a selection of one, the root element, just like `Document.Root` was before). Add jQuery's Closest() method.
 *    **v0.1.1** : Add benchmarks to use as baseline for refactorings, refactor Next...() and Prev...() methods to use the new html package's linked list features (Next/PrevSibling, FirstChild). Good performance boost (40+% in some cases).
+*    **v0.1.0** : Initial release.
 
 ## API
 
@@ -47,53 +52,49 @@ Please note that Cascadia's selectors do NOT necessarily match all supported sel
 
 Taken from example_test.go:
 
-    import (
+```Go
-      "fmt"
+import (
-      // In real use, this import would be required (not in this example, since it
+  "fmt"
-      // is part of the goquery package)
+  // In real use, this import would be required (not in this example, since it
-      //"github.com/PuerkitoBio/goquery"
+  // is part of the goquery package)
-      "strconv"
+  //"github.com/PuerkitoBio/goquery"
-    )
+  "strconv"
+)
 
-    // This example scrapes the 10 reviews shown on the home page of MetalReview.com,
+// This example scrapes the 10 reviews shown on the home page of MetalReview.com,
-    // the best metal review site on the web :) (and no, I'm not affiliated to them!)
+// the best metal review site on the web :) (and no, I'm not affiliated to them!)
-    func ExampleScrape_MetalReview() {
+func ExampleScrape_MetalReview() {
-      // Load the HTML document (in real use, the type would be *goquery.Document)
+  // Load the HTML document (in real use, the type would be *goquery.Document)
-      var doc *Document
+  var doc *Document
-      var e error
+  var e error
-      if doc, e = NewDocument("http://metalreview.com"); e != nil {
-        panic(e.Error())
-      }
 
-      // Find the review items (the type of the Selection would be *goquery.Selection)
+  if doc, e = NewDocument("http://metalreview.com"); e != nil {
-      doc.Root.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) {
+    panic(e.Error())
-        var band, title string
+  }
-        var score float64
 
-        // For each item found, get the band, title and score, and print it
+  // Find the review items (the type of the Selection would be *goquery.Selection)
-        band = s.Find("strong").Text()
+  doc.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) {
-        title = s.Find("em").Text()
+    var band, title string
-        if score, e = strconv.ParseFloat(s.Find(".score").Text(), 64); e != nil {
+    var score float64
-          // Not a valid float, ignore score
-          fmt.Printf("Review %d: %s - %s.\n", i, band, title)
-        } else {
-          // Print all, including score
-          fmt.Printf("Review %d: %s - %s (%2.1f).\n", i, band, title, score)
-        }
-      })
-      // To see the output of the Example while running the test suite (go test), simply
-      // remove the leading "x" before Output on the next line. This will cause the
-      // example to fail (all the "real" tests should pass).
 
-      // xOutput: voluntarily fail the Example output.
+    // For each item found, get the band, title and score, and print it
+    band = s.Find("strong").Text()
+    title = s.Find("em").Text()
+    if score, e = strconv.ParseFloat(s.Find(".score").Text(), 64); e != nil {
+      // Not a valid float, ignore score
+      fmt.Printf("Review %d: %s - %s.\n", i, band, title)
+    } else {
+      // Print all, including score
+      fmt.Printf("Review %d: %s - %s (%2.1f).\n", i, band, title, score)
     }
+  })
+  // To see the output of the Example while running the test suite (go test), simply
+  // remove the leading "x" before Output on the next line. This will cause the
+  // example to fail (all the "real" tests should pass).
 
-
+  // xOutput: voluntarily fail the Example output.
-## TODOs
+}
-<a name="a1" />
+```
-
-*    Add jQuery's `Closest()`? Other missing functions?
-*    Support negative indices in `Slice()`, like jQuery.
 
 ## License
 
@@ -107,5 +108,5 @@ The [BSD 3-Clause license][bsd], the same as the [Go language][golic]. Cascadia'
 [bsd]: http://opensource.org/licenses/BSD-3-Clause
 [golic]: http://golang.org/LICENSE
 [caslic]: http://code.google.com/p/cascadia/source/browse/LICENSE
-[doc]: http://go.pkgdoc.org/github.com/puerkitobio/goquery
+[doc]: http://go.pkgdoc.org/github.com/PuerkitoBio/goquery
 [index]: http://api.jquery.com/index/

array.go

@@ -28,9 +28,14 @@ func (this *Selection) Eq(index int) *Selection {
 }
 
 // Slice() reduces the set of matched elements to a subset specified by a range
-// of indices. At the moment, negative indices are not supported.
+// of indices.
 func (this *Selection) Slice(start int, end int) *Selection {
-	// TODO : Negative indices, like jQuery
+	if start < 0 {
+		start += len(this.Nodes)
+	}
+	if end < 0 {
+		end += len(this.Nodes)
+	}
 	return pushStack(this, this.Nodes[start:end])
 }
 
@@ -58,7 +63,7 @@ func (this *Selection) Index() int {
 // not found.
 func (this *Selection) IndexSelector(selector string) int {
 	if len(this.Nodes) > 0 {
-		sel := this.document.Root.Find(selector)
+		sel := this.document.Find(selector)
 		return indexInSlice(sel.Nodes, this.Nodes[0])
 	}
 	return -1

array_test.go

@@ -5,79 +5,104 @@ import (
 )
 
 func TestFirst(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").First()
+	sel := Doc().Find(".pvk-content").First()
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestFirstEmpty(t *testing.T) {
 	defer AssertPanic(t)
-	Doc().Root.Find(".pvk-zzcontentzz").First()
+	Doc().Find(".pvk-zzcontentzz").First()
 }
 
 func TestFirstRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.First().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestLast(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").Last()
+	sel := Doc().Find(".pvk-content").Last()
 	AssertLength(t, sel.Nodes, 1)
 
 	// Should contain Footer
-	foot := Doc().Root.Find(".footer")
+	foot := Doc().Find(".footer")
 	if !sel.Contains(foot.Nodes[0]) {
 		t.Error("Last .pvk-content should contain .footer.")
 	}
 }
 
 func TestLastRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Last().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestEq(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").Eq(1)
+	sel := Doc().Find(".pvk-content").Eq(1)
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestEqNegative(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").Eq(-1)
+	sel := Doc().Find(".pvk-content").Eq(-1)
 	AssertLength(t, sel.Nodes, 1)
 
 	// Should contain Footer
-	foot := Doc().Root.Find(".footer")
+	foot := Doc().Find(".footer")
 	if !sel.Contains(foot.Nodes[0]) {
 		t.Error("Index -1 of .pvk-content should contain .footer.")
 	}
 }
 
 func TestEqRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Eq(1).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestSlice(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").Slice(0, 2)
+	sel := Doc().Find(".pvk-content").Slice(0, 2)
 
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestSliceOutOfBounds(t *testing.T) {
 	defer AssertPanic(t)
-	Doc().Root.Find(".pvk-content").Slice(2, 12)
+	Doc().Find(".pvk-content").Slice(2, 12)
+}
+
+func TestNegativeSliceStart(t *testing.T) {
+	sel := Doc().Find(".container-fluid").Slice(-2, 3)
+	AssertLength(t, sel.Nodes, 1)
+	AssertSelectionIs(t, sel.Eq(0), "#cf3")
+}
+
+func TestNegativeSliceEnd(t *testing.T) {
+	sel := Doc().Find(".container-fluid").Slice(1, -1)
+	AssertLength(t, sel.Nodes, 2)
+	AssertSelectionIs(t, sel.Eq(0), "#cf2")
+	AssertSelectionIs(t, sel.Eq(1), "#cf3")
+}
+
+func TestNegativeSliceBoth(t *testing.T) {
+	sel := Doc().Find(".container-fluid").Slice(-3, -1)
+	AssertLength(t, sel.Nodes, 2)
+	AssertSelectionIs(t, sel.Eq(0), "#cf2")
+	AssertSelectionIs(t, sel.Eq(1), "#cf3")
+}
+
+func TestNegativeSliceOutOfBounds(t *testing.T) {
+	defer AssertPanic(t)
+	Doc().Find(".container-fluid").Slice(-12, -7)
 }
 
 func TestSliceRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Slice(0, 2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestGet(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	node := sel.Get(1)
 	if sel.Nodes[1] != node {
 		t.Errorf("Expected node %v to be %v.", node, sel.Nodes[1])
@@ -85,7 +110,7 @@ func TestGet(t *testing.T) {
 }
 
 func TestGetNegative(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	node := sel.Get(-3)
 	if sel.Nodes[0] != node {
 		t.Errorf("Expected node %v to be %v.", node, sel.Nodes[0])
@@ -94,41 +119,41 @@ func TestGetNegative(t *testing.T) {
 
 func TestGetInvalid(t *testing.T) {
 	defer AssertPanic(t)
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel.Get(129)
 }
 
 func TestIndex(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	if i := sel.Index(); i != 1 {
 		t.Errorf("Expected index of 1, got %v.", i)
 	}
 }
 
 func TestIndexSelector(t *testing.T) {
-	sel := Doc().Root.Find(".hero-unit")
+	sel := Doc().Find(".hero-unit")
 	if i := sel.IndexSelector("div"); i != 4 {
 		t.Errorf("Expected index of 4, got %v.", i)
 	}
 }
 
 func TestIndexOfNode(t *testing.T) {
-	sel := Doc().Root.Find("div.pvk-gutter")
+	sel := Doc().Find("div.pvk-gutter")
 	if i := sel.IndexOfNode(sel.Nodes[1]); i != 1 {
 		t.Errorf("Expected index of 1, got %v.", i)
 	}
 }
 
 func TestIndexOfNilNode(t *testing.T) {
-	sel := Doc().Root.Find("div.pvk-gutter")
+	sel := Doc().Find("div.pvk-gutter")
 	if i := sel.IndexOfNode(nil); i != -1 {
 		t.Errorf("Expected index of -1, got %v.", i)
 	}
 }
 
 func TestIndexOfSelection(t *testing.T) {
-	sel := Doc().Root.Find("div")
+	sel := Doc().Find("div")
-	sel2 := Doc().Root.Find(".hero-unit")
+	sel2 := Doc().Find(".hero-unit")
 	if i := sel.IndexOfSelection(sel2); i != 4 {
 		t.Errorf("Expected index of 4, got %v.", i)
 	}

bench/v0.2.0

@@ -0,0 +1,459 @@
+PASS
+BenchmarkFirst	20000000	        94.3 ns/op
+BenchmarkLast	20000000	        94.7 ns/op
+BenchmarkEq	20000000	        93.7 ns/op
+BenchmarkSlice	20000000	        89.9 ns/op
+BenchmarkGet	1000000000	         2.72 ns/op
+BenchmarkIndex	 1000000	      1834 ns/op
+--- BENCH: BenchmarkIndex
+bench_array_test.go:73: 	Index=3
+bench_array_test.go:73: 	Index=3
+bench_array_test.go:73: 	Index=3
+bench_array_test.go:73: 	Index=3
+BenchmarkIndexSelector	   50000	     53958 ns/op
+--- BENCH: BenchmarkIndexSelector
+bench_array_test.go:85: 	IndexSelector=4
+bench_array_test.go:85: 	IndexSelector=4
+bench_array_test.go:85: 	IndexSelector=4
+bench_array_test.go:85: 	IndexSelector=4
+BenchmarkIndexOfNode	100000000	        10.1 ns/op
+--- BENCH: BenchmarkIndexOfNode
+bench_array_test.go:99: 	IndexOfNode=2
+bench_array_test.go:99: 	IndexOfNode=2
+bench_array_test.go:99: 	IndexOfNode=2
+bench_array_test.go:99: 	IndexOfNode=2
+bench_array_test.go:99: 	IndexOfNode=2
+BenchmarkIndexOfSelection	100000000	        10.9 ns/op
+--- BENCH: BenchmarkIndexOfSelection
+bench_array_test.go:111: 	IndexOfSelection=2
+bench_array_test.go:111: 	IndexOfSelection=2
+bench_array_test.go:111: 	IndexOfSelection=2
+bench_array_test.go:111: 	IndexOfSelection=2
+bench_array_test.go:111: 	IndexOfSelection=2
+BenchmarkMetalReviewExample	    5000	    326712 ns/op
+--- BENCH: BenchmarkMetalReviewExample
+bench_example_test.go:40: 	Review 0: Midnight - Complete and Total Hell (8.5).
+		Review 1: Over Your Threshold - Facticity (6.0).
+		Review 2: Nuclear Death Terror - Chaos Reigns (7.5).
+		Review 3: Evoken - Atra Mors (9.5).
+		
+		bench_example_test.go:41: 	MetalReviewExample=10
+bench_example_test.go:40: 	Review 0: Midnight - Complete and Total Hell (8.5).
+		Review 1: Over Your Threshold - Facticity (6.0).
+		Review 2: Nuclear Death Terror - Chaos Reigns (7.5).
+		Review 3: Evoken - Atra Mors (9.5).
+	... [output truncated]
+BenchmarkAdd	   50000	     51776 ns/op
+--- BENCH: BenchmarkAdd
+bench_expand_test.go:20: 	Add=43
+bench_expand_test.go:20: 	Add=43
+bench_expand_test.go:20: 	Add=43
+bench_expand_test.go:20: 	Add=43
+BenchmarkAddSelection	10000000	       196 ns/op
+--- BENCH: BenchmarkAddSelection
+bench_expand_test.go:37: 	AddSelection=43
+bench_expand_test.go:37: 	AddSelection=43
+bench_expand_test.go:37: 	AddSelection=43
+bench_expand_test.go:37: 	AddSelection=43
+bench_expand_test.go:37: 	AddSelection=43
+BenchmarkAddNodes	10000000	       191 ns/op
+--- BENCH: BenchmarkAddNodes
+bench_expand_test.go:55: 	AddNodes=43
+bench_expand_test.go:55: 	AddNodes=43
+bench_expand_test.go:55: 	AddNodes=43
+bench_expand_test.go:55: 	AddNodes=43
+bench_expand_test.go:55: 	AddNodes=43
+BenchmarkAndSelf	 1000000	      2495 ns/op
+--- BENCH: BenchmarkAndSelf
+bench_expand_test.go:71: 	AndSelf=44
+bench_expand_test.go:71: 	AndSelf=44
+bench_expand_test.go:71: 	AndSelf=44
+bench_expand_test.go:71: 	AndSelf=44
+BenchmarkFilter	   50000	     30974 ns/op
+--- BENCH: BenchmarkFilter
+bench_filter_test.go:20: 	Filter=13
+bench_filter_test.go:20: 	Filter=13
+bench_filter_test.go:20: 	Filter=13
+bench_filter_test.go:20: 	Filter=13
+BenchmarkNot	   50000	     35322 ns/op
+--- BENCH: BenchmarkNot
+bench_filter_test.go:36: 	Not=371
+bench_filter_test.go:36: 	Not=371
+bench_filter_test.go:36: 	Not=371
+bench_filter_test.go:36: 	Not=371
+BenchmarkFilterFunction	   50000	     65644 ns/op
+--- BENCH: BenchmarkFilterFunction
+bench_filter_test.go:55: 	FilterFunction=112
+bench_filter_test.go:55: 	FilterFunction=112
+bench_filter_test.go:55: 	FilterFunction=112
+bench_filter_test.go:55: 	FilterFunction=112
+BenchmarkNotFunction	   50000	     69245 ns/op
+--- BENCH: BenchmarkNotFunction
+bench_filter_test.go:74: 	NotFunction=261
+bench_filter_test.go:74: 	NotFunction=261
+bench_filter_test.go:74: 	NotFunction=261
+bench_filter_test.go:74: 	NotFunction=261
+BenchmarkFilterNodes	   50000	     64824 ns/op
+--- BENCH: BenchmarkFilterNodes
+bench_filter_test.go:92: 	FilterNodes=2
+bench_filter_test.go:92: 	FilterNodes=2
+bench_filter_test.go:92: 	FilterNodes=2
+bench_filter_test.go:92: 	FilterNodes=2
+BenchmarkNotNodes	   20000	     76247 ns/op
+--- BENCH: BenchmarkNotNodes
+bench_filter_test.go:110: 	NotNodes=360
+bench_filter_test.go:110: 	NotNodes=360
+bench_filter_test.go:110: 	NotNodes=360
+bench_filter_test.go:110: 	NotNodes=360
+BenchmarkFilterSelection	   50000	     66154 ns/op
+--- BENCH: BenchmarkFilterSelection
+bench_filter_test.go:127: 	FilterSelection=2
+bench_filter_test.go:127: 	FilterSelection=2
+bench_filter_test.go:127: 	FilterSelection=2
+bench_filter_test.go:127: 	FilterSelection=2
+BenchmarkNotSelection	   20000	     76336 ns/op
+--- BENCH: BenchmarkNotSelection
+bench_filter_test.go:144: 	NotSelection=360
+bench_filter_test.go:144: 	NotSelection=360
+bench_filter_test.go:144: 	NotSelection=360
+bench_filter_test.go:144: 	NotSelection=360
+BenchmarkHas	    5000	    569495 ns/op
+--- BENCH: BenchmarkHas
+bench_filter_test.go:160: 	Has=13
+bench_filter_test.go:160: 	Has=13
+bench_filter_test.go:160: 	Has=13
+BenchmarkHasNodes	   10000	    227059 ns/op
+--- BENCH: BenchmarkHasNodes
+bench_filter_test.go:178: 	HasNodes=15
+bench_filter_test.go:178: 	HasNodes=15
+bench_filter_test.go:178: 	HasNodes=15
+BenchmarkHasSelection	   10000	    227167 ns/op
+--- BENCH: BenchmarkHasSelection
+bench_filter_test.go:195: 	HasSelection=15
+bench_filter_test.go:195: 	HasSelection=15
+bench_filter_test.go:195: 	HasSelection=15
+BenchmarkEnd	500000000	         3.99 ns/op
+--- BENCH: BenchmarkEnd
+bench_filter_test.go:211: 	End=373
+bench_filter_test.go:211: 	End=373
+bench_filter_test.go:211: 	End=373
+bench_filter_test.go:211: 	End=373
+bench_filter_test.go:211: 	End=373
+bench_filter_test.go:211: 	End=373
+BenchmarkEach	  200000	      9354 ns/op
+--- BENCH: BenchmarkEach
+bench_iteration_test.go:22: 	Each=59
+bench_iteration_test.go:22: 	Each=59
+bench_iteration_test.go:22: 	Each=59
+bench_iteration_test.go:22: 	Each=59
+BenchmarkMap	  100000	     16557 ns/op
+--- BENCH: BenchmarkMap
+bench_iteration_test.go:41: 	Map=59
+bench_iteration_test.go:41: 	Map=59
+bench_iteration_test.go:41: 	Map=59
+bench_iteration_test.go:41: 	Map=59
+BenchmarkAttr	50000000	        36.4 ns/op
+--- BENCH: BenchmarkAttr
+bench_property_test.go:16: 	Attr=firstHeading
+bench_property_test.go:16: 	Attr=firstHeading
+bench_property_test.go:16: 	Attr=firstHeading
+bench_property_test.go:16: 	Attr=firstHeading
+bench_property_test.go:16: 	Attr=firstHeading
+BenchmarkText	  100000	     18473 ns/op
+BenchmarkLength	2000000000	         0.76 ns/op
+--- BENCH: BenchmarkLength
+bench_property_test.go:37: 	Length=14
+bench_property_test.go:37: 	Length=14
+bench_property_test.go:37: 	Length=14
+bench_property_test.go:37: 	Length=14
+bench_property_test.go:37: 	Length=14
+bench_property_test.go:37: 	Length=14
+BenchmarkHtml	 5000000	       666 ns/op
+BenchmarkIs	   50000	     35174 ns/op
+--- BENCH: BenchmarkIs
+bench_query_test.go:16: 	Is=true
+bench_query_test.go:16: 	Is=true
+bench_query_test.go:16: 	Is=true
+bench_query_test.go:16: 	Is=true
+BenchmarkIsPositional	   50000	     31814 ns/op
+--- BENCH: BenchmarkIsPositional
+bench_query_test.go:28: 	IsPositional=true
+bench_query_test.go:28: 	IsPositional=true
+bench_query_test.go:28: 	IsPositional=true
+bench_query_test.go:28: 	IsPositional=true
+BenchmarkIsFunction	 1000000	      2754 ns/op
+--- BENCH: BenchmarkIsFunction
+bench_query_test.go:43: 	IsFunction=true
+bench_query_test.go:43: 	IsFunction=true
+bench_query_test.go:43: 	IsFunction=true
+bench_query_test.go:43: 	IsFunction=true
+BenchmarkIsSelection	   50000	     66260 ns/op
+--- BENCH: BenchmarkIsSelection
+bench_query_test.go:56: 	IsSelection=true
+bench_query_test.go:56: 	IsSelection=true
+bench_query_test.go:56: 	IsSelection=true
+bench_query_test.go:56: 	IsSelection=true
+BenchmarkIsNodes	   50000	     64682 ns/op
+--- BENCH: BenchmarkIsNodes
+bench_query_test.go:70: 	IsNodes=true
+bench_query_test.go:70: 	IsNodes=true
+bench_query_test.go:70: 	IsNodes=true
+bench_query_test.go:70: 	IsNodes=true
+BenchmarkHasClass	    5000	    672953 ns/op
+--- BENCH: BenchmarkHasClass
+bench_query_test.go:82: 	HasClass=true
+bench_query_test.go:82: 	HasClass=true
+bench_query_test.go:82: 	HasClass=true
+BenchmarkContains	100000000	        11.3 ns/op
+--- BENCH: BenchmarkContains
+bench_query_test.go:96: 	Contains=true
+bench_query_test.go:96: 	Contains=true
+bench_query_test.go:96: 	Contains=true
+bench_query_test.go:96: 	Contains=true
+bench_query_test.go:96: 	Contains=true
+BenchmarkFind	   50000	     53780 ns/op
+--- BENCH: BenchmarkFind
+bench_traversal_test.go:18: 	Find=41
+bench_traversal_test.go:18: 	Find=41
+bench_traversal_test.go:18: 	Find=41
+bench_traversal_test.go:18: 	Find=41
+BenchmarkFindWithinSelection	   10000	    125963 ns/op
+--- BENCH: BenchmarkFindWithinSelection
+bench_traversal_test.go:34: 	FindWithinSelection=39
+bench_traversal_test.go:34: 	FindWithinSelection=39
+bench_traversal_test.go:34: 	FindWithinSelection=39
+BenchmarkFindSelection	    5000	    357318 ns/op
+--- BENCH: BenchmarkFindSelection
+bench_traversal_test.go:51: 	FindSelection=73
+bench_traversal_test.go:51: 	FindSelection=73
+bench_traversal_test.go:51: 	FindSelection=73
+BenchmarkFindNodes	    5000	    357587 ns/op
+--- BENCH: BenchmarkFindNodes
+bench_traversal_test.go:69: 	FindNodes=73
+bench_traversal_test.go:69: 	FindNodes=73
+bench_traversal_test.go:69: 	FindNodes=73
+BenchmarkContents	  200000	      9135 ns/op
+--- BENCH: BenchmarkContents
+bench_traversal_test.go:85: 	Contents=16
+bench_traversal_test.go:85: 	Contents=16
+bench_traversal_test.go:85: 	Contents=16
+bench_traversal_test.go:85: 	Contents=16
+BenchmarkContentsFiltered	  200000	     12383 ns/op
+--- BENCH: BenchmarkContentsFiltered
+bench_traversal_test.go:101: 	ContentsFiltered=1
+bench_traversal_test.go:101: 	ContentsFiltered=1
+bench_traversal_test.go:101: 	ContentsFiltered=1
+bench_traversal_test.go:101: 	ContentsFiltered=1
+BenchmarkChildren	 1000000	      1809 ns/op
+--- BENCH: BenchmarkChildren
+bench_traversal_test.go:117: 	Children=2
+bench_traversal_test.go:117: 	Children=2
+bench_traversal_test.go:117: 	Children=2
+bench_traversal_test.go:117: 	Children=2
+BenchmarkChildrenFiltered	  500000	      5814 ns/op
+--- BENCH: BenchmarkChildrenFiltered
+bench_traversal_test.go:133: 	ChildrenFiltered=2
+bench_traversal_test.go:133: 	ChildrenFiltered=2
+bench_traversal_test.go:133: 	ChildrenFiltered=2
+bench_traversal_test.go:133: 	ChildrenFiltered=2
+BenchmarkParent	   50000	     44810 ns/op
+--- BENCH: BenchmarkParent
+bench_traversal_test.go:149: 	Parent=55
+bench_traversal_test.go:149: 	Parent=55
+bench_traversal_test.go:149: 	Parent=55
+bench_traversal_test.go:149: 	Parent=55
+BenchmarkParentFiltered	   50000	     48795 ns/op
+--- BENCH: BenchmarkParentFiltered
+bench_traversal_test.go:165: 	ParentFiltered=4
+bench_traversal_test.go:165: 	ParentFiltered=4
+bench_traversal_test.go:165: 	ParentFiltered=4
+bench_traversal_test.go:165: 	ParentFiltered=4
+BenchmarkParents	   20000	     89102 ns/op
+--- BENCH: BenchmarkParents
+bench_traversal_test.go:181: 	Parents=73
+bench_traversal_test.go:181: 	Parents=73
+bench_traversal_test.go:181: 	Parents=73
+bench_traversal_test.go:181: 	Parents=73
+BenchmarkParentsFiltered	   20000	     93953 ns/op
+--- BENCH: BenchmarkParentsFiltered
+bench_traversal_test.go:197: 	ParentsFiltered=18
+bench_traversal_test.go:197: 	ParentsFiltered=18
+bench_traversal_test.go:197: 	ParentsFiltered=18
+bench_traversal_test.go:197: 	ParentsFiltered=18
+BenchmarkParentsUntil	   10000	    130783 ns/op
+--- BENCH: BenchmarkParentsUntil
+bench_traversal_test.go:213: 	ParentsUntil=52
+bench_traversal_test.go:213: 	ParentsUntil=52
+bench_traversal_test.go:213: 	ParentsUntil=52
+BenchmarkParentsUntilSelection	   10000	    231797 ns/op
+--- BENCH: BenchmarkParentsUntilSelection
+bench_traversal_test.go:230: 	ParentsUntilSelection=70
+bench_traversal_test.go:230: 	ParentsUntilSelection=70
+bench_traversal_test.go:230: 	ParentsUntilSelection=70
+BenchmarkParentsUntilNodes	   10000	    233761 ns/op
+--- BENCH: BenchmarkParentsUntilNodes
+bench_traversal_test.go:248: 	ParentsUntilNodes=70
+bench_traversal_test.go:248: 	ParentsUntilNodes=70
+bench_traversal_test.go:248: 	ParentsUntilNodes=70
+BenchmarkParentsFilteredUntil	   50000	     31360 ns/op
+--- BENCH: BenchmarkParentsFilteredUntil
+bench_traversal_test.go:264: 	ParentsFilteredUntil=2
+bench_traversal_test.go:264: 	ParentsFilteredUntil=2
+bench_traversal_test.go:264: 	ParentsFilteredUntil=2
+bench_traversal_test.go:264: 	ParentsFilteredUntil=2
+BenchmarkParentsFilteredUntilSelection	   50000	     30272 ns/op
+--- BENCH: BenchmarkParentsFilteredUntilSelection
+bench_traversal_test.go:281: 	ParentsFilteredUntilSelection=2
+bench_traversal_test.go:281: 	ParentsFilteredUntilSelection=2
+bench_traversal_test.go:281: 	ParentsFilteredUntilSelection=2
+bench_traversal_test.go:281: 	ParentsFilteredUntilSelection=2
+BenchmarkParentsFilteredUntilNodes	   50000	     30327 ns/op
+--- BENCH: BenchmarkParentsFilteredUntilNodes
+bench_traversal_test.go:299: 	ParentsFilteredUntilNodes=2
+bench_traversal_test.go:299: 	ParentsFilteredUntilNodes=2
+bench_traversal_test.go:299: 	ParentsFilteredUntilNodes=2
+bench_traversal_test.go:299: 	ParentsFilteredUntilNodes=2
+BenchmarkSiblings	   20000	     89862 ns/op
+--- BENCH: BenchmarkSiblings
+bench_traversal_test.go:315: 	Siblings=293
+bench_traversal_test.go:315: 	Siblings=293
+bench_traversal_test.go:315: 	Siblings=293
+bench_traversal_test.go:315: 	Siblings=293
+BenchmarkSiblingsFiltered	   20000	     97948 ns/op
+--- BENCH: BenchmarkSiblingsFiltered
+bench_traversal_test.go:331: 	SiblingsFiltered=46
+bench_traversal_test.go:331: 	SiblingsFiltered=46
+bench_traversal_test.go:331: 	SiblingsFiltered=46
+bench_traversal_test.go:331: 	SiblingsFiltered=46
+BenchmarkNext	   50000	     31975 ns/op
+--- BENCH: BenchmarkNext
+bench_traversal_test.go:347: 	Next=49
+bench_traversal_test.go:347: 	Next=49
+bench_traversal_test.go:347: 	Next=49
+bench_traversal_test.go:347: 	Next=49
+BenchmarkNextFiltered	   50000	     34887 ns/op
+--- BENCH: BenchmarkNextFiltered
+bench_traversal_test.go:363: 	NextFiltered=6
+bench_traversal_test.go:363: 	NextFiltered=6
+bench_traversal_test.go:363: 	NextFiltered=6
+bench_traversal_test.go:363: 	NextFiltered=6
+BenchmarkNextAll	   50000	     60734 ns/op
+--- BENCH: BenchmarkNextAll
+bench_traversal_test.go:379: 	NextAll=234
+bench_traversal_test.go:379: 	NextAll=234
+bench_traversal_test.go:379: 	NextAll=234
+bench_traversal_test.go:379: 	NextAll=234
+BenchmarkNextAllFiltered	   50000	     67428 ns/op
+--- BENCH: BenchmarkNextAllFiltered
+bench_traversal_test.go:395: 	NextAllFiltered=33
+bench_traversal_test.go:395: 	NextAllFiltered=33
+bench_traversal_test.go:395: 	NextAllFiltered=33
+bench_traversal_test.go:395: 	NextAllFiltered=33
+BenchmarkPrev	   50000	     32399 ns/op
+--- BENCH: BenchmarkPrev
+bench_traversal_test.go:411: 	Prev=49
+bench_traversal_test.go:411: 	Prev=49
+bench_traversal_test.go:411: 	Prev=49
+bench_traversal_test.go:411: 	Prev=49
+BenchmarkPrevFiltered	   50000	     34944 ns/op
+--- BENCH: BenchmarkPrevFiltered
+bench_traversal_test.go:429: 	PrevFiltered=7
+bench_traversal_test.go:429: 	PrevFiltered=7
+bench_traversal_test.go:429: 	PrevFiltered=7
+bench_traversal_test.go:429: 	PrevFiltered=7
+BenchmarkPrevAll	  100000	     29360 ns/op
+--- BENCH: BenchmarkPrevAll
+bench_traversal_test.go:445: 	PrevAll=78
+bench_traversal_test.go:445: 	PrevAll=78
+bench_traversal_test.go:445: 	PrevAll=78
+bench_traversal_test.go:445: 	PrevAll=78
+BenchmarkPrevAllFiltered	   50000	     32291 ns/op
+--- BENCH: BenchmarkPrevAllFiltered
+bench_traversal_test.go:461: 	PrevAllFiltered=6
+bench_traversal_test.go:461: 	PrevAllFiltered=6
+bench_traversal_test.go:461: 	PrevAllFiltered=6
+bench_traversal_test.go:461: 	PrevAllFiltered=6
+BenchmarkNextUntil	   10000	    191890 ns/op
+--- BENCH: BenchmarkNextUntil
+bench_traversal_test.go:477: 	NextUntil=84
+bench_traversal_test.go:477: 	NextUntil=84
+bench_traversal_test.go:477: 	NextUntil=84
+BenchmarkNextUntilSelection	   20000	     92054 ns/op
+--- BENCH: BenchmarkNextUntilSelection
+bench_traversal_test.go:494: 	NextUntilSelection=42
+bench_traversal_test.go:494: 	NextUntilSelection=42
+bench_traversal_test.go:494: 	NextUntilSelection=42
+bench_traversal_test.go:494: 	NextUntilSelection=42
+BenchmarkNextUntilNodes	   50000	     43401 ns/op
+--- BENCH: BenchmarkNextUntilNodes
+bench_traversal_test.go:512: 	NextUntilNodes=12
+bench_traversal_test.go:512: 	NextUntilNodes=12
+bench_traversal_test.go:512: 	NextUntilNodes=12
+bench_traversal_test.go:512: 	NextUntilNodes=12
+BenchmarkPrevUntil	    5000	    433383 ns/op
+--- BENCH: BenchmarkPrevUntil
+bench_traversal_test.go:528: 	PrevUntil=238
+bench_traversal_test.go:528: 	PrevUntil=238
+bench_traversal_test.go:528: 	PrevUntil=238
+BenchmarkPrevUntilSelection	   10000	    116423 ns/op
+--- BENCH: BenchmarkPrevUntilSelection
+bench_traversal_test.go:545: 	PrevUntilSelection=49
+bench_traversal_test.go:545: 	PrevUntilSelection=49
+bench_traversal_test.go:545: 	PrevUntilSelection=49
+BenchmarkPrevUntilNodes	   50000	     35338 ns/op
+--- BENCH: BenchmarkPrevUntilNodes
+bench_traversal_test.go:563: 	PrevUntilNodes=11
+bench_traversal_test.go:563: 	PrevUntilNodes=11
+bench_traversal_test.go:563: 	PrevUntilNodes=11
+bench_traversal_test.go:563: 	PrevUntilNodes=11
+BenchmarkNextFilteredUntil	   10000	    104686 ns/op
+--- BENCH: BenchmarkNextFilteredUntil
+bench_traversal_test.go:579: 	NextFilteredUntil=22
+bench_traversal_test.go:579: 	NextFilteredUntil=22
+bench_traversal_test.go:579: 	NextFilteredUntil=22
+BenchmarkNextFilteredUntilSelection	   20000	     99485 ns/op
+--- BENCH: BenchmarkNextFilteredUntilSelection
+bench_traversal_test.go:596: 	NextFilteredUntilSelection=22
+bench_traversal_test.go:596: 	NextFilteredUntilSelection=22
+bench_traversal_test.go:596: 	NextFilteredUntilSelection=22
+bench_traversal_test.go:596: 	NextFilteredUntilSelection=22
+BenchmarkNextFilteredUntilNodes	   20000	     99452 ns/op
+--- BENCH: BenchmarkNextFilteredUntilNodes
+bench_traversal_test.go:614: 	NextFilteredUntilNodes=22
+bench_traversal_test.go:614: 	NextFilteredUntilNodes=22
+bench_traversal_test.go:614: 	NextFilteredUntilNodes=22
+bench_traversal_test.go:614: 	NextFilteredUntilNodes=22
+BenchmarkPrevFilteredUntil	   10000	    112640 ns/op
+--- BENCH: BenchmarkPrevFilteredUntil
+bench_traversal_test.go:630: 	PrevFilteredUntil=20
+bench_traversal_test.go:630: 	PrevFilteredUntil=20
+bench_traversal_test.go:630: 	PrevFilteredUntil=20
+BenchmarkPrevFilteredUntilSelection	   10000	    103702 ns/op
+--- BENCH: BenchmarkPrevFilteredUntilSelection
+bench_traversal_test.go:647: 	PrevFilteredUntilSelection=20
+bench_traversal_test.go:647: 	PrevFilteredUntilSelection=20
+bench_traversal_test.go:647: 	PrevFilteredUntilSelection=20
+BenchmarkPrevFilteredUntilNodes	   10000	    103277 ns/op
+--- BENCH: BenchmarkPrevFilteredUntilNodes
+bench_traversal_test.go:665: 	PrevFilteredUntilNodes=20
+bench_traversal_test.go:665: 	PrevFilteredUntilNodes=20
+bench_traversal_test.go:665: 	PrevFilteredUntilNodes=20
+BenchmarkClosest	  500000	      6530 ns/op
+--- BENCH: BenchmarkClosest
+bench_traversal_test.go:681: 	Closest=2
+bench_traversal_test.go:681: 	Closest=2
+bench_traversal_test.go:681: 	Closest=2
+bench_traversal_test.go:681: 	Closest=2
+BenchmarkClosestSelection	 1000000	      1135 ns/op
+--- BENCH: BenchmarkClosestSelection
+bench_traversal_test.go:698: 	ClosestSelection=2
+bench_traversal_test.go:698: 	ClosestSelection=2
+bench_traversal_test.go:698: 	ClosestSelection=2
+bench_traversal_test.go:698: 	ClosestSelection=2
+BenchmarkClosestNodes	 1000000	      1133 ns/op
+--- BENCH: BenchmarkClosestNodes
+bench_traversal_test.go:715: 	ClosestNodes=2
+bench_traversal_test.go:715: 	ClosestNodes=2
+bench_traversal_test.go:715: 	ClosestNodes=2
+bench_traversal_test.go:715: 	ClosestNodes=2
+ok  	github.com/PuerkitoBio/goquery	192.541s

bench_array_test.go

@@ -6,7 +6,7 @@ import (
 
 func BenchmarkFirst(b *testing.B) {
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sel.First()
@@ -15,7 +15,7 @@ func BenchmarkFirst(b *testing.B) {
 
 func BenchmarkLast(b *testing.B) {
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sel.Last()
@@ -24,7 +24,7 @@ func BenchmarkLast(b *testing.B) {
 
 func BenchmarkEq(b *testing.B) {
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
 	j := 0
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -37,7 +37,7 @@ func BenchmarkEq(b *testing.B) {
 
 func BenchmarkSlice(b *testing.B) {
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
 	j := 0
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -50,7 +50,7 @@ func BenchmarkSlice(b *testing.B) {
 
 func BenchmarkGet(b *testing.B) {
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
 	j := 0
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -65,7 +65,7 @@ func BenchmarkIndex(b *testing.B) {
 	var j int
 
 	b.StopTimer()
-	sel := DocB().Root.Find("#Main")
+	sel := DocB().Find("#Main")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		j = sel.Index()
@@ -77,7 +77,7 @@ func BenchmarkIndexSelector(b *testing.B) {
 	var j int
 
 	b.StopTimer()
-	sel := DocB().Root.Find("#manual-nav dl dd:nth-child(1)")
+	sel := DocB().Find("#manual-nav dl dd:nth-child(1)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		j = sel.IndexSelector("dd")
@@ -89,8 +89,8 @@ func BenchmarkIndexOfNode(b *testing.B) {
 	var j int
 
 	b.StopTimer()
-	sel := DocB().Root.Find("span a")
+	sel := DocB().Find("span a")
-	sel2 := DocB().Root.Find("span a:nth-child(3)")
+	sel2 := DocB().Find("span a:nth-child(3)")
 	n := sel2.Get(0)
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -102,8 +102,8 @@ func BenchmarkIndexOfNode(b *testing.B) {
 func BenchmarkIndexOfSelection(b *testing.B) {
 	var j int
 	b.StopTimer()
-	sel := DocB().Root.Find("span a")
+	sel := DocB().Find("span a")
-	sel2 := DocB().Root.Find("span a:nth-child(3)")
+	sel2 := DocB().Find("span a:nth-child(3)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		j = sel.IndexOfSelection(sel2)

bench_example_test.go

@@ -15,7 +15,7 @@ func BenchmarkMetalReviewExample(b *testing.B) {
 	doc := LoadDoc("metalreview.html")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
-		doc.Root.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) {
+		doc.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) {
 			var band, title string
 			var score float64
 			var e error

bench_expand_test.go

@@ -8,7 +8,7 @@ func BenchmarkAdd(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -24,8 +24,8 @@ func BenchmarkAddSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
-	sel2 := DocB().Root.Find("h2[title]")
+	sel2 := DocB().Find("h2[title]")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -41,8 +41,8 @@ func BenchmarkAddNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocB().Root.Find("dd")
+	sel := DocB().Find("dd")
-	sel2 := DocB().Root.Find("h2[title]")
+	sel2 := DocB().Find("h2[title]")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -59,7 +59,7 @@ func BenchmarkAndSelf(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocB().Root.Find("dd").Parent()
+	sel := DocB().Find("dd").Parent()
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {

bench_filter_test.go

@@ -8,7 +8,7 @@ func BenchmarkFilter(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -24,7 +24,7 @@ func BenchmarkNot(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -40,7 +40,7 @@ func BenchmarkFilterFunction(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	f := func(i int, s *Selection) bool {
 		return len(s.Get(0).Attr) > 0
 	}
@@ -59,7 +59,7 @@ func BenchmarkNotFunction(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	f := func(i int, s *Selection) bool {
 		return len(s.Get(0).Attr) > 0
 	}
@@ -78,8 +78,8 @@ func BenchmarkFilterNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel2 := DocW().Find(".toclevel-2")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -96,8 +96,8 @@ func BenchmarkNotNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".toclevel-1")
+	sel2 := DocW().Find(".toclevel-1")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -114,8 +114,8 @@ func BenchmarkFilterSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel2 := DocW().Find(".toclevel-2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -131,8 +131,8 @@ func BenchmarkNotSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".toclevel-1")
+	sel2 := DocW().Find(".toclevel-1")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -148,7 +148,7 @@ func BenchmarkHas(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -164,8 +164,8 @@ func BenchmarkHasNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".tocnumber")
+	sel2 := DocW().Find(".tocnumber")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -182,8 +182,8 @@ func BenchmarkHasSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".tocnumber")
+	sel2 := DocW().Find(".tocnumber")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -199,7 +199,7 @@ func BenchmarkEnd(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li").Has(".tocnumber")
+	sel := DocW().Find("li").Has(".tocnumber")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {

bench_iteration_test.go

@@ -8,7 +8,7 @@ func BenchmarkEach(b *testing.B) {
 	var tmp, n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("td")
+	sel := DocW().Find("td")
 	f := func(i int, s *Selection) {
 		tmp++
 	}
@@ -26,7 +26,7 @@ func BenchmarkMap(b *testing.B) {
 	var tmp, n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("td")
+	sel := DocW().Find("td")
 	f := func(i int, s *Selection) string {
 		tmp++
 		return string(tmp)

bench_property_test.go

@@ -8,7 +8,7 @@ func BenchmarkAttr(b *testing.B) {
 	var s string
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h1")
+	sel := DocW().Find("h1")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		s, _ = sel.Attr("id")
@@ -18,7 +18,7 @@ func BenchmarkAttr(b *testing.B) {
 
 func BenchmarkText(b *testing.B) {
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sel.Text()
@@ -29,7 +29,7 @@ func BenchmarkLength(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		n = sel.Length()
@@ -39,7 +39,7 @@ func BenchmarkLength(b *testing.B) {
 
 func BenchmarkHtml(b *testing.B) {
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		sel.Html()

bench_query_test.go

@@ -8,7 +8,7 @@ func BenchmarkIs(b *testing.B) {
 	var y bool
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		y = sel.Is(".toclevel-2")
@@ -20,7 +20,7 @@ func BenchmarkIsPositional(b *testing.B) {
 	var y bool
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		y = sel.Is("li:nth-child(2)")
@@ -32,7 +32,7 @@ func BenchmarkIsFunction(b *testing.B) {
 	var y bool
 
 	b.StopTimer()
-	sel := DocW().Root.Find(".toclevel-1")
+	sel := DocW().Find(".toclevel-1")
 	f := func(i int, s *Selection) bool {
 		return i == 8
 	}
@@ -47,8 +47,8 @@ func BenchmarkIsSelection(b *testing.B) {
 	var y bool
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel2 := DocW().Find(".toclevel-2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		y = sel.IsSelection(sel2)
@@ -60,8 +60,8 @@ func BenchmarkIsNodes(b *testing.B) {
 	var y bool
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel2 := DocW().Find(".toclevel-2")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -74,7 +74,7 @@ func BenchmarkHasClass(b *testing.B) {
 	var y bool
 
 	b.StopTimer()
-	sel := DocW().Root.Find("span")
+	sel := DocW().Find("span")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		y = sel.HasClass("official")
@@ -86,8 +86,8 @@ func BenchmarkContains(b *testing.B) {
 	var y bool
 
 	b.StopTimer()
-	sel := DocW().Root.Find("span.url")
+	sel := DocW().Find("span.url")
-	sel2 := DocW().Root.Find("a[rel=\"nofollow\"]")
+	sel2 := DocW().Find("a[rel=\"nofollow\"]")
 	node := sel2.Nodes[0]
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {

bench_traversal_test.go

@@ -9,10 +9,10 @@ func BenchmarkFind(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
-			n = DocB().Root.Find("dd").Length()
+			n = DocB().Find("dd").Length()
 
 		} else {
-			DocB().Root.Find("dd")
+			DocB().Find("dd")
 		}
 	}
 	b.Logf("Find=%d", n)
@@ -22,7 +22,7 @@ func BenchmarkFindWithinSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("ul")
+	sel := DocW().Find("ul")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -38,8 +38,8 @@ func BenchmarkFindSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("ul")
+	sel := DocW().Find("ul")
-	sel2 := DocW().Root.Find("span")
+	sel2 := DocW().Find("span")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -55,8 +55,8 @@ func BenchmarkFindNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("ul")
+	sel := DocW().Find("ul")
-	sel2 := DocW().Root.Find("span")
+	sel2 := DocW().Find("span")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -73,7 +73,7 @@ func BenchmarkContents(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find(".toclevel-1")
+	sel := DocW().Find(".toclevel-1")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -89,7 +89,7 @@ func BenchmarkContentsFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find(".toclevel-1")
+	sel := DocW().Find(".toclevel-1")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -105,7 +105,7 @@ func BenchmarkChildren(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find(".toclevel-2")
+	sel := DocW().Find(".toclevel-2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -121,7 +121,7 @@ func BenchmarkChildrenFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h3")
+	sel := DocW().Find("h3")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -137,7 +137,7 @@ func BenchmarkParent(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -153,7 +153,7 @@ func BenchmarkParentFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li")
+	sel := DocW().Find("li")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -169,7 +169,7 @@ func BenchmarkParents(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("th a")
+	sel := DocW().Find("th a")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -185,7 +185,7 @@ func BenchmarkParentsFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("th a")
+	sel := DocW().Find("th a")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -201,7 +201,7 @@ func BenchmarkParentsUntil(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("th a")
+	sel := DocW().Find("th a")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -217,8 +217,8 @@ func BenchmarkParentsUntilSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("th a")
+	sel := DocW().Find("th a")
-	sel2 := DocW().Root.Find("#content")
+	sel2 := DocW().Find("#content")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -234,8 +234,8 @@ func BenchmarkParentsUntilNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("th a")
+	sel := DocW().Find("th a")
-	sel2 := DocW().Root.Find("#content")
+	sel2 := DocW().Find("#content")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -252,7 +252,7 @@ func BenchmarkParentsFilteredUntil(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find(".toclevel-1 a")
+	sel := DocW().Find(".toclevel-1 a")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -268,8 +268,8 @@ func BenchmarkParentsFilteredUntilSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find(".toclevel-1 a")
+	sel := DocW().Find(".toclevel-1 a")
-	sel2 := DocW().Root.Find("ul")
+	sel2 := DocW().Find("ul")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -285,8 +285,8 @@ func BenchmarkParentsFilteredUntilNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find(".toclevel-1 a")
+	sel := DocW().Find(".toclevel-1 a")
-	sel2 := DocW().Root.Find("ul")
+	sel2 := DocW().Find("ul")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -303,7 +303,7 @@ func BenchmarkSiblings(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("ul li:nth-child(1)")
+	sel := DocW().Find("ul li:nth-child(1)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -319,7 +319,7 @@ func BenchmarkSiblingsFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("ul li:nth-child(1)")
+	sel := DocW().Find("ul li:nth-child(1)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -335,7 +335,7 @@ func BenchmarkNext(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:nth-child(1)")
+	sel := DocW().Find("li:nth-child(1)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -351,7 +351,7 @@ func BenchmarkNextFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:nth-child(1)")
+	sel := DocW().Find("li:nth-child(1)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -367,7 +367,7 @@ func BenchmarkNextAll(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:nth-child(3)")
+	sel := DocW().Find("li:nth-child(3)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -383,7 +383,7 @@ func BenchmarkNextAllFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:nth-child(3)")
+	sel := DocW().Find("li:nth-child(3)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -399,7 +399,7 @@ func BenchmarkPrev(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:last-child")
+	sel := DocW().Find("li:last-child")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -415,7 +415,7 @@ func BenchmarkPrevFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:last-child")
+	sel := DocW().Find("li:last-child")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -433,7 +433,7 @@ func BenchmarkPrevAll(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:nth-child(4)")
+	sel := DocW().Find("li:nth-child(4)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -449,7 +449,7 @@ func BenchmarkPrevAllFiltered(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:nth-child(4)")
+	sel := DocW().Find("li:nth-child(4)")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -465,7 +465,7 @@ func BenchmarkNextUntil(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:first-child")
+	sel := DocW().Find("li:first-child")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -481,8 +481,8 @@ func BenchmarkNextUntilSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("ul")
+	sel2 := DocW().Find("ul")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -498,8 +498,8 @@ func BenchmarkNextUntilNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("p")
+	sel2 := DocW().Find("p")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -516,7 +516,7 @@ func BenchmarkPrevUntil(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("li:last-child")
+	sel := DocW().Find("li:last-child")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -532,8 +532,8 @@ func BenchmarkPrevUntilSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("ul")
+	sel2 := DocW().Find("ul")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -549,8 +549,8 @@ func BenchmarkPrevUntilNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("p")
+	sel2 := DocW().Find("p")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -567,7 +567,7 @@ func BenchmarkNextFilteredUntil(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -583,8 +583,8 @@ func BenchmarkNextFilteredUntilSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("div")
+	sel2 := DocW().Find("div")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -600,8 +600,8 @@ func BenchmarkNextFilteredUntilNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("div")
+	sel2 := DocW().Find("div")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -618,7 +618,7 @@ func BenchmarkPrevFilteredUntil(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -634,8 +634,8 @@ func BenchmarkPrevFilteredUntilSelection(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("div")
+	sel2 := DocW().Find("div")
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		if n == 0 {
@@ -651,8 +651,8 @@ func BenchmarkPrevFilteredUntilNodes(b *testing.B) {
 	var n int
 
 	b.StopTimer()
-	sel := DocW().Root.Find("h2")
+	sel := DocW().Find("h2")
-	sel2 := DocW().Root.Find("div")
+	sel2 := DocW().Find("div")
 	nodes := sel2.Nodes
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
@@ -664,3 +664,53 @@ func BenchmarkPrevFilteredUntilNodes(b *testing.B) {
 	}
 	b.Logf("PrevFilteredUntilNodes=%d", n)
 }
+
+func BenchmarkClosest(b *testing.B) {
+	var n int
+
+	b.StopTimer()
+	sel := Doc().Find(".container-fluid")
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		if n == 0 {
+			n = sel.Closest(".pvk-content").Length()
+		} else {
+			sel.Closest(".pvk-content")
+		}
+	}
+	b.Logf("Closest=%d", n)
+}
+
+func BenchmarkClosestSelection(b *testing.B) {
+	var n int
+
+	b.StopTimer()
+	sel := Doc().Find(".container-fluid")
+	sel2 := Doc().Find(".pvk-content")
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		if n == 0 {
+			n = sel.ClosestSelection(sel2).Length()
+		} else {
+			sel.ClosestSelection(sel2)
+		}
+	}
+	b.Logf("ClosestSelection=%d", n)
+}
+
+func BenchmarkClosestNodes(b *testing.B) {
+	var n int
+
+	b.StopTimer()
+	sel := Doc().Find(".container-fluid")
+	nodes := Doc().Find(".pvk-content").Nodes
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		if n == 0 {
+			n = sel.ClosestNodes(nodes...).Length()
+		} else {
+			sel.ClosestNodes(nodes...)
+		}
+	}
+	b.Logf("ClosestNodes=%d", n)
+}

example_test.go

@@ -20,7 +20,7 @@ func ExampleScrape_MetalReview() {
 	}
 
 	// Find the review items (the type of the Selection would be *goquery.Selection)
-	doc.Root.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) {
+	doc.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) {
 		var band, title string
 		var score float64
 

expand_test.go

@@ -5,25 +5,25 @@ import (
 )
 
 func TestAdd(t *testing.T) {
-	sel := Doc().Root.Find("div.row-fluid").Add("a")
+	sel := Doc().Find("div.row-fluid").Add("a")
 	AssertLength(t, sel.Nodes, 19)
 }
 
 func TestAddRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Add("a").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestAddSelection(t *testing.T) {
-	sel := Doc().Root.Find("div.row-fluid")
+	sel := Doc().Find("div.row-fluid")
-	sel2 := Doc().Root.Find("a")
+	sel2 := Doc().Find("a")
 	sel = sel.AddSelection(sel2)
 	AssertLength(t, sel.Nodes, 19)
 }
 
 func TestAddSelectionNil(t *testing.T) {
-	sel := Doc().Root.Find("div.row-fluid")
+	sel := Doc().Find("div.row-fluid")
 	AssertLength(t, sel.Nodes, 9)
 
 	sel = sel.AddSelection(nil)
@@ -31,38 +31,38 @@ func TestAddSelectionNil(t *testing.T) {
 }
 
 func TestAddSelectionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Find("a")
 	sel2 = sel.AddSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestAddNodes(t *testing.T) {
-	sel := Doc().Root.Find("div.pvk-gutter")
+	sel := Doc().Find("div.pvk-gutter")
-	sel2 := Doc().Root.Find(".pvk-content")
+	sel2 := Doc().Find(".pvk-content")
 	sel = sel.AddNodes(sel2.Nodes...)
 	AssertLength(t, sel.Nodes, 9)
 }
 
 func TestAddNodesNone(t *testing.T) {
-	sel := Doc().Root.Find("div.pvk-gutter").AddNodes()
+	sel := Doc().Find("div.pvk-gutter").AddNodes()
 	AssertLength(t, sel.Nodes, 6)
 }
 
 func TestAddNodesRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Find("a")
 	sel2 = sel.AddNodes(sel2.Nodes...).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestAndSelf(t *testing.T) {
-	sel := Doc().Root.Find(".span12").Last().AndSelf()
+	sel := Doc().Find(".span12").Last().AndSelf()
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestAndSelfRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Find("a").AndSelf().End().End()
 	AssertEqual(t, sel, sel2)
 }

filter.go

@@ -70,7 +70,7 @@ func (this *Selection) Intersection(s *Selection) *Selection {
 // that matches the selector.
 // It returns a new Selection object with the matching elements.
 func (this *Selection) Has(selector string) *Selection {
-	return this.HasSelection(this.document.Root.Find(selector))
+	return this.HasSelection(this.document.Find(selector))
 }
 
 // HasNodes() reduces the set of matched elements to those that have a

filter_test.go

@@ -5,30 +5,30 @@ import (
 )
 
 func TestFilter(t *testing.T) {
-	sel := Doc().Root.Find(".span12").Filter(".alert")
+	sel := Doc().Find(".span12").Filter(".alert")
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestFilterNone(t *testing.T) {
-	sel := Doc().Root.Find(".span12").Filter(".zzalert")
+	sel := Doc().Find(".span12").Filter(".zzalert")
 	AssertLength(t, sel.Nodes, 0)
 }
 
 func TestFilterRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Filter(".alert").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestFilterFunction(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").FilterFunction(func(i int, s *Selection) bool {
+	sel := Doc().Find(".pvk-content").FilterFunction(func(i int, s *Selection) bool {
 		return i > 0
 	})
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestFilterFunctionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.FilterFunction(func(i int, s *Selection) bool {
 		return i > 0
 	}).End()
@@ -36,27 +36,27 @@ func TestFilterFunctionRollback(t *testing.T) {
 }
 
 func TestFilterNode(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.FilterNodes(sel.Nodes[2])
 	AssertLength(t, sel2.Nodes, 1)
 }
 
 func TestFilterNodeRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.FilterNodes(sel.Nodes[2]).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestFilterSelection(t *testing.T) {
-	sel := Doc().Root.Find(".link")
+	sel := Doc().Find(".link")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel2 := Doc().Find("a[ng-click]")
 	sel3 := sel.FilterSelection(sel2)
 	AssertLength(t, sel3.Nodes, 1)
 }
 
 func TestFilterSelectionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".link")
+	sel := Doc().Find(".link")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel2 := Doc().Find("a[ng-click]")
 	sel2 = sel.FilterSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
@@ -64,36 +64,36 @@ func TestFilterSelectionRollback(t *testing.T) {
 func TestFilterSelectionNil(t *testing.T) {
 	var sel2 *Selection
 
-	sel := Doc().Root.Find(".link")
+	sel := Doc().Find(".link")
 	sel3 := sel.FilterSelection(sel2)
 	AssertLength(t, sel3.Nodes, 0)
 }
 
 func TestNot(t *testing.T) {
-	sel := Doc().Root.Find(".span12").Not(".alert")
+	sel := Doc().Find(".span12").Not(".alert")
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestNotRollback(t *testing.T) {
-	sel := Doc().Root.Find(".span12")
+	sel := Doc().Find(".span12")
 	sel2 := sel.Not(".alert").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNotNone(t *testing.T) {
-	sel := Doc().Root.Find(".span12").Not(".zzalert")
+	sel := Doc().Find(".span12").Not(".zzalert")
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestNotFunction(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").NotFunction(func(i int, s *Selection) bool {
+	sel := Doc().Find(".pvk-content").NotFunction(func(i int, s *Selection) bool {
 		return i > 0
 	})
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestNotFunctionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.NotFunction(func(i int, s *Selection) bool {
 		return i > 0
 	}).End()
@@ -101,91 +101,91 @@ func TestNotFunctionRollback(t *testing.T) {
 }
 
 func TestNotNode(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.NotNodes(sel.Nodes[2])
 	AssertLength(t, sel2.Nodes, 2)
 }
 
 func TestNotNodeRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.NotNodes(sel.Nodes[2]).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNotSelection(t *testing.T) {
-	sel := Doc().Root.Find(".link")
+	sel := Doc().Find(".link")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel2 := Doc().Find("a[ng-click]")
 	sel3 := sel.NotSelection(sel2)
 	AssertLength(t, sel3.Nodes, 6)
 }
 
 func TestNotSelectionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".link")
+	sel := Doc().Find(".link")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel2 := Doc().Find("a[ng-click]")
 	sel2 = sel.NotSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestIntersection(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter")
+	sel := Doc().Find(".pvk-gutter")
-	sel2 := Doc().Root.Find("div").Intersection(sel)
+	sel2 := Doc().Find("div").Intersection(sel)
 	AssertLength(t, sel2.Nodes, 6)
 }
 
 func TestIntersectionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter")
+	sel := Doc().Find(".pvk-gutter")
-	sel2 := Doc().Root.Find("div")
+	sel2 := Doc().Find("div")
 	sel2 = sel.Intersection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestHas(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").Has(".center-content")
+	sel := Doc().Find(".container-fluid").Has(".center-content")
 	AssertLength(t, sel.Nodes, 2)
 	// Has() returns the high-level .container-fluid div, and the one that is the immediate parent of center-content
 }
 
 func TestHasRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.Has(".center-content").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestHasNodes(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".center-content")
+	sel2 := Doc().Find(".center-content")
 	sel = sel.HasNodes(sel2.Nodes...)
 	AssertLength(t, sel.Nodes, 2)
 	// Has() returns the high-level .container-fluid div, and the one that is the immediate parent of center-content
 }
 
 func TestHasNodesRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".center-content")
+	sel2 := Doc().Find(".center-content")
 	sel2 = sel.HasNodes(sel2.Nodes...).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestHasSelection(t *testing.T) {
-	sel := Doc().Root.Find("p")
+	sel := Doc().Find("p")
-	sel2 := Doc().Root.Find("small")
+	sel2 := Doc().Find("small")
 	sel = sel.HasSelection(sel2)
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestHasSelectionRollback(t *testing.T) {
-	sel := Doc().Root.Find("p")
+	sel := Doc().Find("p")
-	sel2 := Doc().Root.Find("small")
+	sel2 := Doc().Find("small")
 	sel2 = sel.HasSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestEnd(t *testing.T) {
-	sel := Doc().Root.Find("p").Has("small").End()
+	sel := Doc().Find("p").Has("small").End()
 	AssertLength(t, sel.Nodes, 4)
 }
 
 func TestEndToTop(t *testing.T) {
-	sel := Doc().Root.Find("p").Has("small").End().End().End()
+	sel := Doc().Find("p").Has("small").End().End().End()
 	AssertLength(t, sel.Nodes, 0)
 }

iteration_test.go

@@ -8,7 +8,7 @@ import (
 func TestEach(t *testing.T) {
 	var cnt int
 
-	sel := Doc().Root.Find(".hero-unit .row-fluid").Each(func(i int, n *Selection) {
+	sel := Doc().Find(".hero-unit .row-fluid").Each(func(i int, n *Selection) {
 		cnt++
 		t.Logf("At index %v, node %v", i, n.Nodes[0].Data)
 	}).Find("a")
@@ -22,7 +22,7 @@ func TestEach(t *testing.T) {
 func TestEachEmptySelection(t *testing.T) {
 	var cnt int
 
-	sel := Doc().Root.Find("zzzz")
+	sel := Doc().Find("zzzz")
 	sel.Each(func(i int, n *Selection) {
 		cnt++
 	})
@@ -34,7 +34,7 @@ func TestEachEmptySelection(t *testing.T) {
 }
 
 func TestMap(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	vals := sel.Map(func(i int, s *Selection) string {
 		n := s.Get(0)
 		if n.Type == html.ElementNode {

property_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func TestAttrExists(t *testing.T) {
-	if val, ok := Doc().Root.Find("a").Attr("href"); !ok {
+	if val, ok := Doc().Find("a").Attr("href"); !ok {
 		t.Error("Expected a value for the href attribute.")
 	} else {
 		t.Logf("Href of first anchor: %v.", val)
@@ -15,20 +15,20 @@ func TestAttrExists(t *testing.T) {
 }
 
 func TestAttrNotExist(t *testing.T) {
-	if val, ok := Doc().Root.Find("div.row-fluid").Attr("href"); ok {
+	if val, ok := Doc().Find("div.row-fluid").Attr("href"); ok {
 		t.Errorf("Expected no value for the href attribute, got %v.", val)
 	}
 }
 
 func TestText(t *testing.T) {
-	txt := Doc().Root.Find("h1").Text()
+	txt := Doc().Find("h1").Text()
 	if strings.Trim(txt, " \n\r\t") != "Provok.in" {
 		t.Errorf("Expected text to be Provok.in, found %s.", txt)
 	}
 }
 
 func TestText2(t *testing.T) {
-	txt := Doc().Root.Find(".hero-unit .container-fluid .row-fluid:nth-child(1)").Text()
+	txt := Doc().Find(".hero-unit .container-fluid .row-fluid:nth-child(1)").Text()
 	if ok, e := regexp.MatchString(`^\s+Provok\.in\s+Prove your point.\s+$`, txt); !ok || e != nil {
 		t.Errorf("Expected text to be Provok.in Prove your point., found %s.", txt)
 		if e != nil {
@@ -38,7 +38,7 @@ func TestText2(t *testing.T) {
 }
 
 func TestText3(t *testing.T) {
-	txt := Doc().Root.Find(".pvk-gutter").First().Text()
+	txt := Doc().Find(".pvk-gutter").First().Text()
 	// There's an   character in there...
 	if ok, e := regexp.MatchString(`^[\s\x{00A0}]+$`, txt); !ok || e != nil {
 		t.Errorf("Expected spaces, found <%v>.", txt)
@@ -49,7 +49,7 @@ func TestText3(t *testing.T) {
 }
 
 func TestHtml(t *testing.T) {
-	txt, e := Doc().Root.Find("h1").Html()
+	txt, e := Doc().Find("h1").Html()
 	if e != nil {
 		t.Errorf("Error: %s.", e)
 	}

query.go

@@ -7,30 +7,10 @@ import (
 	"strings"
 )
 
-//var rxNeedsContext = `^[\x20\t\r\n\f]*[>+~]|:(nth|eq|gt|lt|first|last|even|odd)(-child)?(?:\((\d*)\)|)(?:[^-]|$)`
-
 // Is() checks the current matched set of elements against a selector and
 // returns true if at least one of these elements matches.
 func (this *Selection) Is(selector string) bool {
 	if len(this.Nodes) > 0 {
-		// The selector must be done on the document if it has positional criteria
-
-		// TODO : Not sure it is required, as Cascadia's selector checks within the parent of the
-		// node when there is such a positionaly selector... In jQuery, this is for the 
-		// non-css selectors (Sizzle-implemented selectors, an extension of CSS)
-
-		/*if ok, e := regexp.MatchString(rxNeedsContext, selector); ok {
-			sel := this.document.Root.Find(selector)
-			for _, n := range this.Nodes {
-				if sel.IndexOfNode(n) > -1 {
-					return true
-				}
-			}
-
-		} else if e != nil {
-			panic(e.Error())
-
-		} else {*/
 		// Attempt a match with the selector
 		cs := cascadia.MustCompile(selector)
 		if len(this.Nodes) == 1 {
@@ -38,7 +18,6 @@ func (this *Selection) Is(selector string) bool {
 		} else {
 			return len(cs.Filter(this.Nodes)) > 0
 		}
-		//}
 	}
 
 	return false

query_test.go

@@ -5,28 +5,28 @@ import (
 )
 
 func TestIs(t *testing.T) {
-	sel := Doc().Root.Find(".footer p:nth-child(1)")
+	sel := Doc().Find(".footer p:nth-child(1)")
 	if !sel.Is("p") {
 		t.Error("Expected .footer p:nth-child(1) to be p.")
 	}
 }
 
 func TestIsPositional(t *testing.T) {
-	sel := Doc().Root.Find(".footer p:nth-child(2)")
+	sel := Doc().Find(".footer p:nth-child(2)")
 	if !sel.Is("p:nth-child(2)") {
 		t.Error("Expected .footer p:nth-child(2) to be p:nth-child(2).")
 	}
 }
 
 func TestIsPositionalNot(t *testing.T) {
-	sel := Doc().Root.Find(".footer p:nth-child(1)")
+	sel := Doc().Find(".footer p:nth-child(1)")
 	if sel.Is("p:nth-child(2)") {
 		t.Error("Expected .footer p:nth-child(1) NOT to be p:nth-child(2).")
 	}
 }
 
 func TestIsFunction(t *testing.T) {
-	ok := Doc().Root.Find("div").IsFunction(func(i int, s *Selection) bool {
+	ok := Doc().Find("div").IsFunction(func(i int, s *Selection) bool {
 		return s.HasClass("container-fluid")
 	})
 
@@ -36,7 +36,7 @@ func TestIsFunction(t *testing.T) {
 }
 
 func TestIsFunctionRollback(t *testing.T) {
-	ok := Doc().Root.Find("div").IsFunction(func(i int, s *Selection) bool {
+	ok := Doc().Find("div").IsFunction(func(i int, s *Selection) bool {
 		return s.HasClass("container-fluid")
 	})
 
@@ -46,8 +46,8 @@ func TestIsFunctionRollback(t *testing.T) {
 }
 
 func TestIsSelection(t *testing.T) {
-	sel := Doc().Root.Find("div")
+	sel := Doc().Find("div")
-	sel2 := Doc().Root.Find(".pvk-gutter")
+	sel2 := Doc().Find(".pvk-gutter")
 
 	if !sel.IsSelection(sel2) {
 		t.Error("Expected some div to have a pvk-gutter class.")
@@ -55,8 +55,8 @@ func TestIsSelection(t *testing.T) {
 }
 
 func TestIsSelectionNot(t *testing.T) {
-	sel := Doc().Root.Find("div")
+	sel := Doc().Find("div")
-	sel2 := Doc().Root.Find("a")
+	sel2 := Doc().Find("a")
 
 	if sel.IsSelection(sel2) {
 		t.Error("Expected some div NOT to be an anchor.")
@@ -64,8 +64,8 @@ func TestIsSelectionNot(t *testing.T) {
 }
 
 func TestIsNodes(t *testing.T) {
-	sel := Doc().Root.Find("div")
+	sel := Doc().Find("div")
-	sel2 := Doc().Root.Find(".footer")
+	sel2 := Doc().Find(".footer")
 
 	if !sel.IsNodes(sel2.Nodes[0]) {
 		t.Error("Expected some div to have a footer class.")
@@ -73,44 +73,44 @@ func TestIsNodes(t *testing.T) {
 }
 
 func TestHasClass(t *testing.T) {
-	sel := Doc().Root.Find("div")
+	sel := Doc().Find("div")
 	if !sel.HasClass("span12") {
 		t.Error("Expected at least one div to have class span12.")
 	}
 }
 
 func TestHasClassNone(t *testing.T) {
-	sel := Doc().Root.Find("h2")
+	sel := Doc().Find("h2")
 	if sel.HasClass("toto") {
 		t.Error("Expected h1 to have no class.")
 	}
 }
 
 func TestHasClassNotFirst(t *testing.T) {
-	sel := Doc().Root.Find(".alert")
+	sel := Doc().Find(".alert")
 	if !sel.HasClass("alert-error") {
 		t.Error("Expected .alert to also have class .alert-error.")
 	}
 }
 
 func TestDocContains(t *testing.T) {
-	sel := Doc().Root.Find("h1")
+	sel := Doc().Find("h1")
-	if !Doc().Root.Contains(sel.Nodes[0]) {
+	if !Doc().Contains(sel.Nodes[0]) {
 		t.Error("Expected document to contain H1 tag.")
 	}
 }
 
 func TestSelContains(t *testing.T) {
-	sel := Doc().Root.Find(".row-fluid")
+	sel := Doc().Find(".row-fluid")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel2 := Doc().Find("a[ng-click]")
 	if !sel.Contains(sel2.Nodes[0]) {
 		t.Error("Expected .row-fluid to contain a[ng-click] tag.")
 	}
 }
 
 func TestSelNotContains(t *testing.T) {
-	sel := Doc().Root.Find("a.link")
+	sel := Doc().Find("a.link")
-	sel2 := Doc().Root.Find("span")
+	sel2 := Doc().Find("span")
 	if sel.Contains(sel2.Nodes[0]) {
 		t.Error("Expected a.link to NOT contain span tag.")
 	}

testdata/page.html

@@ -19,7 +19,7 @@
                 <div class="pvk-gutter">
                     &nbsp;
                 </div>
-                <div class="pvk-content">
+                <div class="pvk-content" id="pc1">
                     <div ng-controller="HeroCtrl" class="hero-unit">
                         <div class="container-fluid" id="cf2">
                             <div class="row-fluid" id="cf2-1">
@@ -54,7 +54,7 @@
                 <div class="pvk-gutter">
                     &nbsp;
                 </div>
-                <div class="pvk-content">
+                <div class="pvk-content" id="pc2">
                     <div class="container-fluid" id="cf3">
                         <div class="row-fluid">
                             <div ng-cloak="" view-on-display="" ng-controller="MsgCtrl" ng-class="{'displayed': blockIsDisplayed}" class="message-box">

traversal.go

@@ -93,6 +93,48 @@ func (this *Selection) ParentFiltered(selector string) *Selection {
 	return filterAndPush(this, getParentNodes(this.Nodes), selector)
 }
 
+// Closest() gets the first element that matches the selector by testing the
+// element itself and traversing up through its ancestors in the DOM tree.
+func (this *Selection) Closest(selector string) *Selection {
+	cs := cascadia.MustCompile(selector)
+
+	return pushStack(this, mapNodes(this.Nodes, func(i int, n *html.Node) []*html.Node {
+		// For each node in the selection, test the node itself, then each parent
+		// until a match is found.
+		for ; n != nil; n = n.Parent {
+			if cs.Match(n) {
+				return []*html.Node{n}
+			}
+		}
+		return nil
+	}))
+}
+
+// ClosestNodes() gets the first element that matches one of the nodes by testing the
+// element itself and traversing up through its ancestors in the DOM tree.
+func (this *Selection) ClosestNodes(nodes ...*html.Node) *Selection {
+	return pushStack(this, mapNodes(this.Nodes, func(i int, n *html.Node) []*html.Node {
+		// For each node in the selection, test the node itself, then each parent
+		// until a match is found.
+		for ; n != nil; n = n.Parent {
+			if isInSlice(nodes, n) {
+				return []*html.Node{n}
+			}
+		}
+		return nil
+	}))
+}
+
+// ClosestSelection() gets the first element that matches one of the nodes in the 
+// Selection by testing the element itself and traversing up through its ancestors
+// in the DOM tree.
+func (this *Selection) ClosestSelection(s *Selection) *Selection {
+	if s == nil {
+		return pushStack(this, nil)
+	}
+	return this.ClosestNodes(s.Nodes...)
+}
+
 // Parents() gets the ancestors of each element in the current Selection. It
 // returns a new Selection object with the matched elements.
 func (this *Selection) Parents() *Selection {
@@ -372,7 +414,6 @@ func getParentsNodes(nodes []*html.Node, stopSelector string, stopNodes []*html.
 
 // Internal implementation of sibling nodes that return a raw slice of matches.
 func getSiblingNodes(nodes []*html.Node, st siblingType, untilSelector string, untilNodes []*html.Node) []*html.Node {
-
 	var f func(*html.Node) bool
 
 	// If the requested siblings are ...Until(), create the test function to 

traversal_test.go

@@ -5,574 +5,671 @@ import (
 )
 
 func TestFind(t *testing.T) {
-	sel := Doc().Root.Find("div.row-fluid")
+	sel := Doc().Find("div.row-fluid")
 	AssertLength(t, sel.Nodes, 9)
 }
 
 func TestFindRollback(t *testing.T) {
-	sel := Doc().Root.Find("div.row-fluid")
+	sel := Doc().Find("div.row-fluid")
 	sel2 := sel.Find("a").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestFindNotSelf(t *testing.T) {
-	sel := Doc().Root.Find("h1").Find("h1")
+	sel := Doc().Find("h1").Find("h1")
 	AssertLength(t, sel.Nodes, 0)
 }
 
 func TestFindInvalidSelector(t *testing.T) {
 	defer AssertPanic(t)
-	Doc().Root.Find(":+ ^")
+	Doc().Find(":+ ^")
 }
 
 func TestChainedFind(t *testing.T) {
-	sel := Doc().Root.Find("div.hero-unit").Find(".row-fluid")
+	sel := Doc().Find("div.hero-unit").Find(".row-fluid")
 	AssertLength(t, sel.Nodes, 4)
 }
 
 func TestChildren(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").Children()
+	sel := Doc().Find(".pvk-content").Children()
 	AssertLength(t, sel.Nodes, 5)
 }
 
 func TestChildrenRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Children().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestContents(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").Contents()
+	sel := Doc().Find(".pvk-content").Contents()
 	AssertLength(t, sel.Nodes, 13)
 }
 
 func TestContentsRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.Contents().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestChildrenFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").ChildrenFiltered(".hero-unit")
+	sel := Doc().Find(".pvk-content").ChildrenFiltered(".hero-unit")
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestChildrenFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.ChildrenFiltered(".hero-unit").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestContentsFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").ContentsFiltered(".hero-unit")
+	sel := Doc().Find(".pvk-content").ContentsFiltered(".hero-unit")
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestContentsFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".pvk-content")
 	sel2 := sel.ContentsFiltered(".hero-unit").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestChildrenFilteredNone(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-content").ChildrenFiltered("a.btn")
+	sel := Doc().Find(".pvk-content").ChildrenFiltered("a.btn")
 	AssertLength(t, sel.Nodes, 0)
 }
 
 func TestParent(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").Parent()
+	sel := Doc().Find(".container-fluid").Parent()
 	AssertLength(t, sel.Nodes, 3)
 }
 
 func TestParentRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.Parent().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentBody(t *testing.T) {
-	sel := Doc().Root.Find("body").Parent()
+	sel := Doc().Find("body").Parent()
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestParentFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").ParentFiltered(".hero-unit")
+	sel := Doc().Find(".container-fluid").ParentFiltered(".hero-unit")
 	AssertLength(t, sel.Nodes, 1)
 	AssertClass(t, sel, "hero-unit")
 }
 
 func TestParentFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.ParentFiltered(".hero-unit").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParents(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").Parents()
+	sel := Doc().Find(".container-fluid").Parents()
 	AssertLength(t, sel.Nodes, 8)
 }
 
 func TestParentsOrder(t *testing.T) {
-	sel := Doc().Root.Find("#cf2").Parents()
+	sel := Doc().Find("#cf2").Parents()
 	AssertLength(t, sel.Nodes, 6)
 	AssertSelectionIs(t, sel, ".hero-unit", ".pvk-content", "div.row-fluid", "#cf1", "body", "html")
 }
 
 func TestParentsRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.Parents().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentsFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").ParentsFiltered("body")
+	sel := Doc().Find(".container-fluid").ParentsFiltered("body")
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestParentsFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.ParentsFiltered("body").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentsUntil(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").ParentsUntil("body")
+	sel := Doc().Find(".container-fluid").ParentsUntil("body")
 	AssertLength(t, sel.Nodes, 6)
 }
 
 func TestParentsUntilRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.ParentsUntil("body").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentsUntilSelection(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".pvk-content")
+	sel2 := Doc().Find(".pvk-content")
 	sel = sel.ParentsUntilSelection(sel2)
 	AssertLength(t, sel.Nodes, 3)
 }
 
 func TestParentsUntilSelectionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".pvk-content")
+	sel2 := Doc().Find(".pvk-content")
 	sel2 = sel.ParentsUntilSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentsUntilNodes(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".pvk-content, .hero-unit")
+	sel2 := Doc().Find(".pvk-content, .hero-unit")
 	sel = sel.ParentsUntilNodes(sel2.Nodes...)
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestParentsUntilNodesRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".pvk-content, .hero-unit")
+	sel2 := Doc().Find(".pvk-content, .hero-unit")
 	sel2 = sel.ParentsUntilNodes(sel2.Nodes...).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentsFilteredUntil(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").ParentsFilteredUntil(".pvk-content", "body")
+	sel := Doc().Find(".container-fluid").ParentsFilteredUntil(".pvk-content", "body")
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestParentsFilteredUntilRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.ParentsFilteredUntil(".pvk-content", "body").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentsFilteredUntilSelection(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel2 := Doc().Find(".row-fluid")
 	sel = sel.ParentsFilteredUntilSelection("div", sel2)
 	AssertLength(t, sel.Nodes, 3)
 }
 
 func TestParentsFilteredUntilSelectionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel2 := Doc().Find(".row-fluid")
 	sel2 = sel.ParentsFilteredUntilSelection("div", sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestParentsFilteredUntilNodes(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel2 := Doc().Find(".row-fluid")
 	sel = sel.ParentsFilteredUntilNodes("body", sel2.Nodes...)
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestParentsFilteredUntilNodesRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel2 := Doc().Find(".row-fluid")
 	sel2 = sel.ParentsFilteredUntilNodes("body", sel2.Nodes...).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestSiblings(t *testing.T) {
-	sel := Doc().Root.Find("h1").Siblings()
+	sel := Doc().Find("h1").Siblings()
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestSiblingsRollback(t *testing.T) {
-	sel := Doc().Root.Find("h1")
+	sel := Doc().Find("h1")
 	sel2 := sel.Siblings().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestSiblings2(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter").Siblings()
+	sel := Doc().Find(".pvk-gutter").Siblings()
 	AssertLength(t, sel.Nodes, 9)
 }
 
 func TestSiblings3(t *testing.T) {
-	sel := Doc().Root.Find("body>.container-fluid").Siblings()
+	sel := Doc().Find("body>.container-fluid").Siblings()
 	AssertLength(t, sel.Nodes, 0)
 }
 
 func TestSiblingsFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter").SiblingsFiltered(".pvk-content")
+	sel := Doc().Find(".pvk-gutter").SiblingsFiltered(".pvk-content")
 	AssertLength(t, sel.Nodes, 3)
 }
 
 func TestSiblingsFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter")
+	sel := Doc().Find(".pvk-gutter")
 	sel2 := sel.SiblingsFiltered(".pvk-content").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNext(t *testing.T) {
-	sel := Doc().Root.Find("h1").Next()
+	sel := Doc().Find("h1").Next()
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestNextRollback(t *testing.T) {
-	sel := Doc().Root.Find("h1")
+	sel := Doc().Find("h1")
 	sel2 := sel.Next().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNext2(t *testing.T) {
-	sel := Doc().Root.Find(".close").Next()
+	sel := Doc().Find(".close").Next()
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestNextNone(t *testing.T) {
-	sel := Doc().Root.Find("small").Next()
+	sel := Doc().Find("small").Next()
 	AssertLength(t, sel.Nodes, 0)
 }
 
 func TestNextFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").NextFiltered("div")
+	sel := Doc().Find(".container-fluid").NextFiltered("div")
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestNextFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid")
+	sel := Doc().Find(".container-fluid")
 	sel2 := sel.NextFiltered("div").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextFiltered2(t *testing.T) {
-	sel := Doc().Root.Find(".container-fluid").NextFiltered("[ng-view]")
+	sel := Doc().Find(".container-fluid").NextFiltered("[ng-view]")
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestPrev(t *testing.T) {
-	sel := Doc().Root.Find(".red").Prev()
+	sel := Doc().Find(".red").Prev()
 	AssertLength(t, sel.Nodes, 1)
 	AssertClass(t, sel, "green")
 }
 
 func TestPrevRollback(t *testing.T) {
-	sel := Doc().Root.Find(".red")
+	sel := Doc().Find(".red")
 	sel2 := sel.Prev().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestPrev2(t *testing.T) {
-	sel := Doc().Root.Find(".row-fluid").Prev()
+	sel := Doc().Find(".row-fluid").Prev()
 	AssertLength(t, sel.Nodes, 5)
 }
 
 func TestPrevNone(t *testing.T) {
-	sel := Doc().Root.Find("h2").Prev()
+	sel := Doc().Find("h2").Prev()
 	AssertLength(t, sel.Nodes, 0)
 }
 
 func TestPrevFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".row-fluid").PrevFiltered(".row-fluid")
+	sel := Doc().Find(".row-fluid").PrevFiltered(".row-fluid")
 	AssertLength(t, sel.Nodes, 5)
 }
 
 func TestPrevFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".row-fluid")
+	sel := Doc().Find(".row-fluid")
 	sel2 := sel.PrevFiltered(".row-fluid").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextAll(t *testing.T) {
-	sel := Doc().Root.Find("#cf2 div:nth-child(1)").NextAll()
+	sel := Doc().Find("#cf2 div:nth-child(1)").NextAll()
 	AssertLength(t, sel.Nodes, 3)
 }
 
 func TestNextAllRollback(t *testing.T) {
-	sel := Doc().Root.Find("#cf2 div:nth-child(1)")
+	sel := Doc().Find("#cf2 div:nth-child(1)")
 	sel2 := sel.NextAll().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextAll2(t *testing.T) {
-	sel := Doc().Root.Find("div[ng-cloak]").NextAll()
+	sel := Doc().Find("div[ng-cloak]").NextAll()
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestNextAllNone(t *testing.T) {
-	sel := Doc().Root.Find(".footer").NextAll()
+	sel := Doc().Find(".footer").NextAll()
 	AssertLength(t, sel.Nodes, 0)
 }
 
 func TestNextAllFiltered(t *testing.T) {
-	sel := Doc().Root.Find("#cf2 .row-fluid").NextAllFiltered("[ng-cloak]")
+	sel := Doc().Find("#cf2 .row-fluid").NextAllFiltered("[ng-cloak]")
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestNextAllFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find("#cf2 .row-fluid")
+	sel := Doc().Find("#cf2 .row-fluid")
 	sel2 := sel.NextAllFiltered("[ng-cloak]").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextAllFiltered2(t *testing.T) {
-	sel := Doc().Root.Find(".close").NextAllFiltered("h4")
+	sel := Doc().Find(".close").NextAllFiltered("h4")
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestPrevAll(t *testing.T) {
-	sel := Doc().Root.Find("[ng-view]").PrevAll()
+	sel := Doc().Find("[ng-view]").PrevAll()
 	AssertLength(t, sel.Nodes, 2)
 }
 
 func TestPrevAllOrder(t *testing.T) {
-	sel := Doc().Root.Find("[ng-view]").PrevAll()
+	sel := Doc().Find("[ng-view]").PrevAll()
 	AssertLength(t, sel.Nodes, 2)
 	AssertSelectionIs(t, sel, "#cf4", "#cf3")
 }
 
 func TestPrevAllRollback(t *testing.T) {
-	sel := Doc().Root.Find("[ng-view]")
+	sel := Doc().Find("[ng-view]")
 	sel2 := sel.PrevAll().End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestPrevAll2(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter").PrevAll()
+	sel := Doc().Find(".pvk-gutter").PrevAll()
 	AssertLength(t, sel.Nodes, 6)
 }
 
 func TestPrevAllFiltered(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter").PrevAllFiltered(".pvk-content")
+	sel := Doc().Find(".pvk-gutter").PrevAllFiltered(".pvk-content")
 	AssertLength(t, sel.Nodes, 3)
 }
 
 func TestPrevAllFilteredRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter")
+	sel := Doc().Find(".pvk-gutter")
 	sel2 := sel.PrevAllFiltered(".pvk-content").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextUntil(t *testing.T) {
-	sel := Doc().Root.Find(".alert a").NextUntil("p")
+	sel := Doc().Find(".alert a").NextUntil("p")
 	AssertLength(t, sel.Nodes, 1)
 	AssertSelectionIs(t, sel, "h4")
 }
 
 func TestNextUntil2(t *testing.T) {
-	sel := Doc().Root.Find("#cf2-1").NextUntil("[ng-cloak]")
+	sel := Doc().Find("#cf2-1").NextUntil("[ng-cloak]")
 	AssertLength(t, sel.Nodes, 1)
 	AssertSelectionIs(t, sel, "#cf2-2")
 }
 
 func TestNextUntilOrder(t *testing.T) {
-	sel := Doc().Root.Find("#cf2-1").NextUntil("#cf2-4")
+	sel := Doc().Find("#cf2-1").NextUntil("#cf2-4")
 	AssertLength(t, sel.Nodes, 2)
 	AssertSelectionIs(t, sel, "#cf2-2", "#cf2-3")
 }
 
 func TestNextUntilRollback(t *testing.T) {
-	sel := Doc().Root.Find("#cf2-1")
+	sel := Doc().Find("#cf2-1")
 	sel2 := sel.PrevUntil("#cf2-4").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextUntilSelection(t *testing.T) {
-	sel := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n2")
-	sel2 := Doc2().Root.Find("#n4")
+	sel2 := Doc2().Find("#n4")
 	sel2 = sel.NextUntilSelection(sel2)
 	AssertLength(t, sel2.Nodes, 1)
 	AssertSelectionIs(t, sel2, "#n3")
 }
 
 func TestNextUntilSelectionRollback(t *testing.T) {
-	sel := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n2")
-	sel2 := Doc2().Root.Find("#n4")
+	sel2 := Doc2().Find("#n4")
 	sel2 = sel.NextUntilSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n2")
-	sel2 := Doc2().Root.Find("#n5")
+	sel2 := Doc2().Find("#n5")
 	sel2 = sel.NextUntilNodes(sel2.Nodes...)
 	AssertLength(t, sel2.Nodes, 2)
 	AssertSelectionIs(t, sel2, "#n3", "#n4")
 }
 
 func TestNextUntilNodesRollback(t *testing.T) {
-	sel := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n2")
-	sel2 := Doc2().Root.Find("#n5")
+	sel2 := Doc2().Find("#n5")
 	sel2 = sel.NextUntilNodes(sel2.Nodes...).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestPrevUntil(t *testing.T) {
-	sel := Doc().Root.Find(".alert p").PrevUntil("a")
+	sel := Doc().Find(".alert p").PrevUntil("a")
 	AssertLength(t, sel.Nodes, 1)
 	AssertSelectionIs(t, sel, "h4")
 }
 
 func TestPrevUntil2(t *testing.T) {
-	sel := Doc().Root.Find("[ng-cloak]").PrevUntil(":not([ng-cloak])")
+	sel := Doc().Find("[ng-cloak]").PrevUntil(":not([ng-cloak])")
 	AssertLength(t, sel.Nodes, 1)
 	AssertSelectionIs(t, sel, "[ng-cloak]")
 }
 
 func TestPrevUntilOrder(t *testing.T) {
-	sel := Doc().Root.Find("#cf2-4").PrevUntil("#cf2-1")
+	sel := Doc().Find("#cf2-4").PrevUntil("#cf2-1")
 	AssertLength(t, sel.Nodes, 2)
 	AssertSelectionIs(t, sel, "#cf2-3", "#cf2-2")
 }
 
 func TestPrevUntilRollback(t *testing.T) {
-	sel := Doc().Root.Find("#cf2-4")
+	sel := Doc().Find("#cf2-4")
 	sel2 := sel.PrevUntil("#cf2-1").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestPrevUntilSelection(t *testing.T) {
-	sel := Doc2().Root.Find("#n4")
+	sel := Doc2().Find("#n4")
-	sel2 := Doc2().Root.Find("#n2")
+	sel2 := Doc2().Find("#n2")
 	sel2 = sel.PrevUntilSelection(sel2)
 	AssertLength(t, sel2.Nodes, 1)
 	AssertSelectionIs(t, sel2, "#n3")
 }
 
 func TestPrevUntilSelectionRollback(t *testing.T) {
-	sel := Doc2().Root.Find("#n4")
+	sel := Doc2().Find("#n4")
-	sel2 := Doc2().Root.Find("#n2")
+	sel2 := Doc2().Find("#n2")
 	sel2 = sel.PrevUntilSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestPrevUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find("#n5")
+	sel := Doc2().Find("#n5")
-	sel2 := Doc2().Root.Find("#n2")
+	sel2 := Doc2().Find("#n2")
 	sel2 = sel.PrevUntilNodes(sel2.Nodes...)
 	AssertLength(t, sel2.Nodes, 2)
 	AssertSelectionIs(t, sel2, "#n4", "#n3")
 }
 
 func TestPrevUntilNodesRollback(t *testing.T) {
-	sel := Doc2().Root.Find("#n5")
+	sel := Doc2().Find("#n5")
-	sel2 := Doc2().Root.Find("#n2")
+	sel2 := Doc2().Find("#n2")
 	sel2 = sel.PrevUntilNodes(sel2.Nodes...).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextFilteredUntil(t *testing.T) {
-	sel := Doc2().Root.Find(".two").NextFilteredUntil(".even", ".six")
+	sel := Doc2().Find(".two").NextFilteredUntil(".even", ".six")
 	AssertLength(t, sel.Nodes, 4)
 	AssertSelectionIs(t, sel, "#n3", "#n5", "#nf3", "#nf5")
 }
 
 func TestNextFilteredUntilRollback(t *testing.T) {
-	sel := Doc2().Root.Find(".two")
+	sel := Doc2().Find(".two")
 	sel2 := sel.NextFilteredUntil(".even", ".six").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextFilteredUntilSelection(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
+	sel := Doc2().Find(".even")
-	sel2 := Doc2().Root.Find(".five")
+	sel2 := Doc2().Find(".five")
 	sel = sel.NextFilteredUntilSelection(".even", sel2)
 	AssertLength(t, sel.Nodes, 2)
 	AssertSelectionIs(t, sel, "#n3", "#nf3")
 }
 
 func TestNextFilteredUntilSelectionRollback(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
+	sel := Doc2().Find(".even")
-	sel2 := Doc2().Root.Find(".five")
+	sel2 := Doc2().Find(".five")
 	sel3 := sel.NextFilteredUntilSelection(".even", sel2).End()
 	AssertEqual(t, sel, sel3)
 }
 
 func TestNextFilteredUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
+	sel := Doc2().Find(".even")
-	sel2 := Doc2().Root.Find(".four")
+	sel2 := Doc2().Find(".four")
 	sel = sel.NextFilteredUntilNodes(".odd", sel2.Nodes...)
 	AssertLength(t, sel.Nodes, 4)
 	AssertSelectionIs(t, sel, "#n2", "#n6", "#nf2", "#nf6")
 }
 
 func TestNextFilteredUntilNodesRollback(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
+	sel := Doc2().Find(".even")
-	sel2 := Doc2().Root.Find(".four")
+	sel2 := Doc2().Find(".four")
 	sel3 := sel.NextFilteredUntilNodes(".odd", sel2.Nodes...).End()
 	AssertEqual(t, sel, sel3)
 }
 
 func TestPrevFilteredUntil(t *testing.T) {
-	sel := Doc2().Root.Find(".five").PrevFilteredUntil(".odd", ".one")
+	sel := Doc2().Find(".five").PrevFilteredUntil(".odd", ".one")
 	AssertLength(t, sel.Nodes, 4)
 	AssertSelectionIs(t, sel, "#n4", "#n2", "#nf4", "#nf2")
 }
 
 func TestPrevFilteredUntilRollback(t *testing.T) {
-	sel := Doc2().Root.Find(".four")
+	sel := Doc2().Find(".four")
 	sel2 := sel.PrevFilteredUntil(".odd", ".one").End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestPrevFilteredUntilSelection(t *testing.T) {
-	sel := Doc2().Root.Find(".odd")
+	sel := Doc2().Find(".odd")
-	sel2 := Doc2().Root.Find(".two")
+	sel2 := Doc2().Find(".two")
 	sel = sel.PrevFilteredUntilSelection(".odd", sel2)
 	AssertLength(t, sel.Nodes, 2)
 	AssertSelectionIs(t, sel, "#n4", "#nf4")
 }
 
 func TestPrevFilteredUntilSelectionRollback(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
+	sel := Doc2().Find(".even")
-	sel2 := Doc2().Root.Find(".five")
+	sel2 := Doc2().Find(".five")
 	sel3 := sel.PrevFilteredUntilSelection(".even", sel2).End()
 	AssertEqual(t, sel, sel3)
 }
 
 func TestPrevFilteredUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
+	sel := Doc2().Find(".even")
-	sel2 := Doc2().Root.Find(".four")
+	sel2 := Doc2().Find(".four")
 	sel = sel.PrevFilteredUntilNodes(".odd", sel2.Nodes...)
 	AssertLength(t, sel.Nodes, 2)
 	AssertSelectionIs(t, sel, "#n2", "#nf2")
 }
 
 func TestPrevFilteredUntilNodesRollback(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
+	sel := Doc2().Find(".even")
-	sel2 := Doc2().Root.Find(".four")
+	sel2 := Doc2().Find(".four")
 	sel3 := sel.PrevFilteredUntilNodes(".odd", sel2.Nodes...).End()
 	AssertEqual(t, sel, sel3)
 }
+
+func TestClosestItself(t *testing.T) {
+	sel := Doc2().Find(".three")
+	sel2 := sel.Closest(".row")
+	AssertLength(t, sel2.Nodes, sel.Length())
+	AssertSelectionIs(t, sel2, "#n3", "#nf3")
+}
+
+func TestClosestNoDupes(t *testing.T) {
+	sel := Doc().Find(".span12")
+	sel2 := sel.Closest(".pvk-content")
+	AssertLength(t, sel2.Nodes, 1)
+	AssertClass(t, sel2, "pvk-content")
+}
+
+func TestClosestNone(t *testing.T) {
+	sel := Doc().Find("h4")
+	sel2 := sel.Closest("a")
+	AssertLength(t, sel2.Nodes, 0)
+}
+
+func TestClosestMany(t *testing.T) {
+	sel := Doc().Find(".container-fluid")
+	sel2 := sel.Closest(".pvk-content")
+	AssertLength(t, sel2.Nodes, 2)
+	AssertSelectionIs(t, sel2, "#pc1", "#pc2")
+}
+
+func TestClosestRollback(t *testing.T) {
+	sel := Doc().Find(".container-fluid")
+	sel2 := sel.Closest(".pvk-content").End()
+	AssertEqual(t, sel, sel2)
+}
+
+func TestClosestSelectionItself(t *testing.T) {
+	sel := Doc2().Find(".three")
+	sel2 := sel.ClosestSelection(Doc2().Find(".row"))
+	AssertLength(t, sel2.Nodes, sel.Length())
+}
+
+func TestClosestSelectionNoDupes(t *testing.T) {
+	sel := Doc().Find(".span12")
+	sel2 := sel.ClosestSelection(Doc().Find(".pvk-content"))
+	AssertLength(t, sel2.Nodes, 1)
+	AssertClass(t, sel2, "pvk-content")
+}
+
+func TestClosestSelectionNone(t *testing.T) {
+	sel := Doc().Find("h4")
+	sel2 := sel.ClosestSelection(Doc().Find("a"))
+	AssertLength(t, sel2.Nodes, 0)
+}
+
+func TestClosestSelectionMany(t *testing.T) {
+	sel := Doc().Find(".container-fluid")
+	sel2 := sel.ClosestSelection(Doc().Find(".pvk-content"))
+	AssertLength(t, sel2.Nodes, 2)
+	AssertSelectionIs(t, sel2, "#pc1", "#pc2")
+}
+
+func TestClosestSelectionRollback(t *testing.T) {
+	sel := Doc().Find(".container-fluid")
+	sel2 := sel.ClosestSelection(Doc().Find(".pvk-content")).End()
+	AssertEqual(t, sel, sel2)
+}
+
+func TestClosestNodesItself(t *testing.T) {
+	sel := Doc2().Find(".three")
+	sel2 := sel.ClosestNodes(Doc2().Find(".row").Nodes...)
+	AssertLength(t, sel2.Nodes, sel.Length())
+}
+
+func TestClosestNodesNoDupes(t *testing.T) {
+	sel := Doc().Find(".span12")
+	sel2 := sel.ClosestNodes(Doc().Find(".pvk-content").Nodes...)
+	AssertLength(t, sel2.Nodes, 1)
+	AssertClass(t, sel2, "pvk-content")
+}
+
+func TestClosestNodesNone(t *testing.T) {
+	sel := Doc().Find("h4")
+	sel2 := sel.ClosestNodes(Doc().Find("a").Nodes...)
+	AssertLength(t, sel2.Nodes, 0)
+}
+
+func TestClosestNodesMany(t *testing.T) {
+	sel := Doc().Find(".container-fluid")
+	sel2 := sel.ClosestNodes(Doc().Find(".pvk-content").Nodes...)
+	AssertLength(t, sel2.Nodes, 2)
+	AssertSelectionIs(t, sel2, "#pc1", "#pc2")
+}
+
+func TestClosestNodesRollback(t *testing.T) {
+	sel := Doc().Find(".container-fluid")
+	sel2 := sel.ClosestNodes(Doc().Find(".pvk-content").Nodes...).End()
+	AssertEqual(t, sel, sel2)
+}

type.go

@@ -12,7 +12,7 @@ import (
 // to be told, and that's what the Document class is for. It holds the root
 // document node to manipulate, and can make selections on this document.
 type Document struct {
-	Root     *Selection
+	*Selection
 	Url      *url.URL
 	rootNode *html.Node
 }
@@ -49,7 +49,7 @@ func NewDocument(url string) (d *Document, e error) {
 func newDocument(root *html.Node, url *url.URL) (d *Document) {
 	// Create and fill the document
 	d = &Document{nil, url, root}
-	d.Root = newSingleSelection(root, d)
+	d.Selection = newSingleSelection(root, d)
 	return
 }