update readme with new version

Update exp/html import paths, closes #7

.gitignore

@@ -1,2 +1,4 @@
 *.sublime-*
 .DS_Store
+*.swp
+#*.*#

README.md

@@ -1,6 +1,6 @@
 # goquery - a little like that j-thing, only in Go
 
-GoQuery brings a syntax and a set of features similar to [jQuery][] to the [Go language][go]. It is based on the [experimental html package][exphtml] and the CSS Selector library [cascadia][]. Since the experimental html parser returns tokens (nodes), and not a full-featured DOM object, jQuery's manipulation and modification functions have been left off (no point in modifying data in the parsed tree of the HTML, it has no effect).
+GoQuery brings a syntax and a set of features similar to [jQuery][] to the [Go language][go]. It is based on the experimental html package and the CSS Selector library [cascadia][]. Since the experimental html parser returns tokens (nodes), and not a full-featured DOM object, jQuery's manipulation and modification functions have been left off (no point in modifying data in the parsed tree of the HTML, it has no effect).
 
 Supported functions are query-oriented features (`hasClass()`, `attr()` and the likes), as well as traversing functions that make sense given what we have to work with. This makes GoQuery a great library for scraping web pages.
 
@@ -8,24 +8,24 @@ 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].
+    $ go get github.com/PuerkitoBio/goquery
 
-Once this is done, install GoQuery:
+(optional) To run unit tests:
+    
+    $ cd $GOPATH/src/github.com/PuerkitoBio/goquery
+    $ go test
 
-`go get github.com/PuerkitoBio/goquery`
+(optional) To run benchmarks:
 
-To run unit tests, run this command in goquery's source directory (`$GOPATH/src/github.com/PuerkitoBio/goquery`):
-
-`go test`
-
-To run benchmarks, run this command in goquery's source directory:
-
-`go test -bench=".*"`
+    $ cd $GOPATH/src/github.com/PuerkitoBio/goquery
+    $ go test -bench=".*"
 
 ## Changelog
 
-*    **v0.1.0** : Initial release. See [TODOs](#a1) for a list of upcoming features.
+*    **v0.2.1** : Make go-getable, now that [go.net/html is Go1.0-compatible][gonet] (thanks to @matrixik for pointing this out).
+*    **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 +47,49 @@ Please note that Cascadia's selectors do NOT necessarily match all supported sel
 
 Taken from example_test.go:
 
-    import (
-      "fmt"
-      // In real use, this import would be required (not in this example, since it
-      // is part of the goquery package)
-      //"github.com/PuerkitoBio/goquery"
-      "strconv"
-    )
+```Go
+import (
+  "fmt"
+  // In real use, this import would be required (not in this example, since it
+  // is part of the goquery package)
+  //"github.com/PuerkitoBio/goquery"
+  "strconv"
+)
 
-    // 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!)
-    func ExampleScrape_MetalReview() {
-      // Load the HTML document (in real use, the type would be *goquery.Document)
-      var doc *Document
-      var e error
-      if doc, e = NewDocument("http://metalreview.com"); e != nil {
-        panic(e.Error())
-      }
+// 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!)
+func ExampleScrape_MetalReview() {
+  // Load the HTML document (in real use, the type would be *goquery.Document)
+  var doc *Document
+  var e error
 
-      // 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) {
-        var band, title string
-        var score float64
+  if doc, e = NewDocument("http://metalreview.com"); e != nil {
+    panic(e.Error())
+  }
 
-        // 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).
+  // Find the review items (the type of the Selection would be *goquery.Selection)
+  doc.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) {
+    var band, title string
+    var score float64
 
-      // 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).
 
-
-## TODOs
-<a name="a1" />
-
-*    Add jQuery's `Closest()`? Other missing functions?
-*    Support negative indices in `Slice()`, like jQuery.
+  // xOutput: voluntarily fail the Example output.
+}
+```
 
 ## License
 
@@ -101,11 +97,10 @@ The [BSD 3-Clause license][bsd], the same as the [Go language][golic]. Cascadia'
 
 [jquery]: http://jquery.com/
 [go]: http://golang.org/
-[exphtml]: http://code.google.com/p/go/source/browse#hg%2Fsrc%2Fpkg%2Fexp
 [cascadia]: http://code.google.com/p/cascadia/
-[wikiexp]: http://code.google.com/p/go-wiki/wiki/InstallingExp
 [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://godoc.org/github.com/PuerkitoBio/goquery
 [index]: http://api.jquery.com/index/
+[gonet]: http://code.google.com/p/go/source/detail?r=f7f5159120f51ba0070774d3c5907969b5fe7858&repo=net

array.go

@@ -1,7 +1,7 @@
 package goquery
 
 import (
-	"exp/html"
+	"code.google.com/p/go.net/html"
 )
 
 // First() reduces the set of matched elements to the first in the set.
@@ -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")
-	sel2 := Doc().Root.Find(".hero-unit")
+	sel := Doc().Find("div")
+	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")
-	sel2 := DocB().Root.Find("span a:nth-child(3)")
+	sel := DocB().Find("span a")
+	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")
-	sel2 := DocB().Root.Find("span a:nth-child(3)")
+	sel := DocB().Find("span a")
+	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")
-	sel2 := DocB().Root.Find("h2[title]")
+	sel := DocB().Find("dd")
+	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")
-	sel2 := DocB().Root.Find("h2[title]")
+	sel := DocB().Find("dd")
+	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")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find(".toclevel-1")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find(".toclevel-1")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find(".tocnumber")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find(".tocnumber")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find(".toclevel-2")
+	sel := DocW().Find("li")
+	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")
-	sel2 := DocW().Root.Find("a[rel=\"nofollow\"]")
+	sel := DocW().Find("span.url")
+	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")
-	sel2 := DocW().Root.Find("span")
+	sel := DocW().Find("ul")
+	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")
-	sel2 := DocW().Root.Find("span")
+	sel := DocW().Find("ul")
+	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")
-	sel2 := DocW().Root.Find("#content")
+	sel := DocW().Find("th a")
+	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")
-	sel2 := DocW().Root.Find("#content")
+	sel := DocW().Find("th a")
+	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")
-	sel2 := DocW().Root.Find("ul")
+	sel := DocW().Find(".toclevel-1 a")
+	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")
-	sel2 := DocW().Root.Find("ul")
+	sel := DocW().Find(".toclevel-1 a")
+	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")
-	sel2 := DocW().Root.Find("ul")
+	sel := DocW().Find("h2")
+	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")
-	sel2 := DocW().Root.Find("p")
+	sel := DocW().Find("h2")
+	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")
-	sel2 := DocW().Root.Find("ul")
+	sel := DocW().Find("h2")
+	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")
-	sel2 := DocW().Root.Find("p")
+	sel := DocW().Find("h2")
+	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")
-	sel2 := DocW().Root.Find("div")
+	sel := DocW().Find("h2")
+	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")
-	sel2 := DocW().Root.Find("div")
+	sel := DocW().Find("h2")
+	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")
-	sel2 := DocW().Root.Find("div")
+	sel := DocW().Find("h2")
+	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")
-	sel2 := DocW().Root.Find("div")
+	sel := DocW().Find("h2")
+	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)
+}

doc.go

@@ -26,7 +26,7 @@ Package goquery implements features similar to jQuery, including the chainable
 syntax, to manipulate and query an HTML document (the modification functions of jQuery are not included).
 
 It depends on Go's experimental html package, which must be installed so that it
-can be imported as "exp/html". See this tutorial on how to install it 
+can be imported as "code.google.com/p/go.net/html". See this tutorial on how to install it 
 accordingly: http://code.google.com/p/go-wiki/wiki/InstallingExp
 
 It uses Cascadia as CSS selector (similar to Sizzle for jQuery). This dependency

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.go

@@ -1,7 +1,7 @@
 package goquery
 
 import (
-	"exp/html"
+	"code.google.com/p/go.net/html"
 )
 
 // Add() adds the selector string's matching nodes to those in the current

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")
-	sel2 := Doc().Root.Find("a")
+	sel := Doc().Find("div.row-fluid")
+	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")
-	sel2 := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find("div.pvk-gutter")
+	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

@@ -2,7 +2,7 @@ package goquery
 
 import (
 	"code.google.com/p/cascadia"
-	"exp/html"
+	"code.google.com/p/go.net/html"
 )
 
 // Filter() reduces the set of matched elements to those that match the selector string.
@@ -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")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel := Doc().Find(".link")
+	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")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel := Doc().Find(".link")
+	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")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel := Doc().Find(".link")
+	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")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel := Doc().Find(".link")
+	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")
-	sel2 := Doc().Root.Find("div").Intersection(sel)
+	sel := Doc().Find(".pvk-gutter")
+	sel2 := Doc().Find("div").Intersection(sel)
 	AssertLength(t, sel2.Nodes, 6)
 }
 
 func TestIntersectionRollback(t *testing.T) {
-	sel := Doc().Root.Find(".pvk-gutter")
-	sel2 := Doc().Root.Find("div")
+	sel := Doc().Find(".pvk-gutter")
+	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")
-	sel2 := Doc().Root.Find(".center-content")
+	sel := Doc().Find(".container-fluid")
+	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")
-	sel2 := Doc().Root.Find(".center-content")
+	sel := Doc().Find(".container-fluid")
+	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")
-	sel2 := Doc().Root.Find("small")
+	sel := Doc().Find("p")
+	sel2 := Doc().Find("small")
 	sel = sel.HasSelection(sel2)
 	AssertLength(t, sel.Nodes, 1)
 }
 
 func TestHasSelectionRollback(t *testing.T) {
-	sel := Doc().Root.Find("p")
-	sel2 := Doc().Root.Find("small")
+	sel := Doc().Find("p")
+	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

@@ -1,14 +1,14 @@
 package goquery
 
 import (
-	"exp/html"
+	"code.google.com/p/go.net/html"
 	"testing"
 )
 
 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.go

@@ -2,7 +2,7 @@ package goquery
 
 import (
 	"bytes"
-	"exp/html"
+	"code.google.com/p/go.net/html"
 )
 
 // Attr() gets the specified attribute's value for the first element in the

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

@@ -2,35 +2,15 @@ package goquery
 
 import (
 	"code.google.com/p/cascadia"
-	"exp/html"
+	"code.google.com/p/go.net/html"
 	"regexp"
 	"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")
-	sel2 := Doc().Root.Find(".pvk-gutter")
+	sel := Doc().Find("div")
+	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")
-	sel2 := Doc().Root.Find("a")
+	sel := Doc().Find("div")
+	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")
-	sel2 := Doc().Root.Find(".footer")
+	sel := Doc().Find("div")
+	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")
-	if !Doc().Root.Contains(sel.Nodes[0]) {
+	sel := Doc().Find("h1")
+	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")
-	sel2 := Doc().Root.Find("a[ng-click]")
+	sel := Doc().Find(".row-fluid")
+	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")
-	sel2 := Doc().Root.Find("span")
+	sel := Doc().Find("a.link")
+	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

@@ -2,7 +2,7 @@ package goquery
 
 import (
 	"code.google.com/p/cascadia"
-	"exp/html"
+	"code.google.com/p/go.net/html"
 )
 
 type siblingType int
@@ -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")
-	sel2 := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".container-fluid")
+	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")
-	sel2 := Doc().Root.Find(".pvk-content")
+	sel := Doc().Find(".container-fluid")
+	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")
-	sel2 := Doc().Root.Find(".pvk-content, .hero-unit")
+	sel := Doc().Find(".container-fluid")
+	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")
-	sel2 := Doc().Root.Find(".pvk-content, .hero-unit")
+	sel := Doc().Find(".container-fluid")
+	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")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel := Doc().Find(".container-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")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel := Doc().Find(".container-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")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel := Doc().Find(".container-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")
-	sel2 := Doc().Root.Find(".row-fluid")
+	sel := Doc().Find(".container-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")
-	sel2 := Doc2().Root.Find("#n4")
+	sel := Doc2().Find("#n2")
+	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")
-	sel2 := Doc2().Root.Find("#n4")
+	sel := Doc2().Find("#n2")
+	sel2 := Doc2().Find("#n4")
 	sel2 = sel.NextUntilSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestNextUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find("#n2")
-	sel2 := Doc2().Root.Find("#n5")
+	sel := Doc2().Find("#n2")
+	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")
-	sel2 := Doc2().Root.Find("#n5")
+	sel := Doc2().Find("#n2")
+	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")
-	sel2 := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n4")
+	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")
-	sel2 := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n4")
+	sel2 := Doc2().Find("#n2")
 	sel2 = sel.PrevUntilSelection(sel2).End()
 	AssertEqual(t, sel, sel2)
 }
 
 func TestPrevUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find("#n5")
-	sel2 := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n5")
+	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")
-	sel2 := Doc2().Root.Find("#n2")
+	sel := Doc2().Find("#n5")
+	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")
-	sel2 := Doc2().Root.Find(".five")
+	sel := Doc2().Find(".even")
+	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")
-	sel2 := Doc2().Root.Find(".five")
+	sel := Doc2().Find(".even")
+	sel2 := Doc2().Find(".five")
 	sel3 := sel.NextFilteredUntilSelection(".even", sel2).End()
 	AssertEqual(t, sel, sel3)
 }
 
 func TestNextFilteredUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
-	sel2 := Doc2().Root.Find(".four")
+	sel := Doc2().Find(".even")
+	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")
-	sel2 := Doc2().Root.Find(".four")
+	sel := Doc2().Find(".even")
+	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")
-	sel2 := Doc2().Root.Find(".two")
+	sel := Doc2().Find(".odd")
+	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")
-	sel2 := Doc2().Root.Find(".five")
+	sel := Doc2().Find(".even")
+	sel2 := Doc2().Find(".five")
 	sel3 := sel.PrevFilteredUntilSelection(".even", sel2).End()
 	AssertEqual(t, sel, sel3)
 }
 
 func TestPrevFilteredUntilNodes(t *testing.T) {
-	sel := Doc2().Root.Find(".even")
-	sel2 := Doc2().Root.Find(".four")
+	sel := Doc2().Find(".even")
+	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")
-	sel2 := Doc2().Root.Find(".four")
+	sel := Doc2().Find(".even")
+	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

@@ -1,7 +1,7 @@
 package goquery
 
 import (
-	"exp/html"
+	"code.google.com/p/go.net/html"
 	"net/http"
 	"net/url"
 )
@@ -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
 }
 

type_test.go

@@ -1,7 +1,7 @@
 package goquery
 
 import (
-	"exp/html"
+	"code.google.com/p/go.net/html"
 	"fmt"
 	"os"
 	"testing"

utilities.go

@@ -1,7 +1,7 @@
 package goquery
 
 import (
-	"exp/html"
+	"code.google.com/p/go.net/html"
 )
 
 func getChildren(n *html.Node) (result []*html.Node) {