From 6669ef001f4d5d2a7edfb8b16d475dddfab1b9f3 Mon Sep 17 00:00:00 2001 From: Martin Angers Date: Sun, 14 Oct 2012 12:28:27 -0400 Subject: [PATCH] remove Document.Root, Document is itself a Selection (using embedded struct) --- README.md | 2 +- array.go | 2 +- array_test.go | 52 ++++----- bench_array_test.go | 22 ++-- bench_example_test.go | 2 +- bench_expand_test.go | 12 +- bench_filter_test.go | 36 +++--- bench_iteration_test.go | 4 +- bench_property_test.go | 8 +- bench_query_test.go | 20 ++-- bench_traversal_test.go | 110 +++++++++--------- example_test.go | 2 +- expand_test.go | 24 ++-- filter.go | 2 +- filter_test.go | 78 ++++++------- iteration_test.go | 6 +- property_test.go | 12 +- query_test.go | 40 +++---- traversal_test.go | 240 ++++++++++++++++++++-------------------- type.go | 4 +- 20 files changed, 339 insertions(+), 339 deletions(-) diff --git a/README.md b/README.md index d437105..cc2ec17 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ To run benchmarks, run this command in goquery's source directory: ## Changelog -* **v0.2.0** : Add support for negative indices in Slice(). *Upcoming* : add jQuery's Closest() method. +* **v0.2.0** : (*in progress on master branch*) Add support for negative indices in Slice(). *Upcoming* : 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. See [TODOs](#a1) for a list of upcoming features. diff --git a/array.go b/array.go index 3e76244..b2d7412 100644 --- a/array.go +++ b/array.go @@ -63,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 diff --git a/array_test.go b/array_test.go index 599d88e..13b6ca2 100644 --- a/array_test.go +++ b/array_test.go @@ -5,86 +5,86 @@ 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().Root.Find(".container-fluid").Slice(-2, 3) + 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().Root.Find(".container-fluid").Slice(1, -1) + 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().Root.Find(".container-fluid").Slice(-3, -1) + 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") @@ -92,17 +92,17 @@ func TestNegativeSliceBoth(t *testing.T) { func TestNegativeSliceOutOfBounds(t *testing.T) { defer AssertPanic(t) - Doc().Root.Find(".container-fluid").Slice(-12, -7) + 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]) @@ -110,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]) @@ -119,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) } diff --git a/bench_array_test.go b/bench_array_test.go index b291c7f..6d5581e 100644 --- a/bench_array_test.go +++ b/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) diff --git a/bench_example_test.go b/bench_example_test.go index 07f7c82..3f03ca5 100644 --- a/bench_example_test.go +++ b/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 diff --git a/bench_expand_test.go b/bench_expand_test.go index ad63d7e..aee7d81 100644 --- a/bench_expand_test.go +++ b/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 { diff --git a/bench_filter_test.go b/bench_filter_test.go index 9db293a..05ffaaa 100644 --- a/bench_filter_test.go +++ b/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 { diff --git a/bench_iteration_test.go b/bench_iteration_test.go index 437fba9..51582b7 100644 --- a/bench_iteration_test.go +++ b/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) diff --git a/bench_property_test.go b/bench_property_test.go index c57a721..0e61603 100644 --- a/bench_property_test.go +++ b/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() diff --git a/bench_query_test.go b/bench_query_test.go index 2a68ad6..3d3a98f 100644 --- a/bench_query_test.go +++ b/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++ { diff --git a/bench_traversal_test.go b/bench_traversal_test.go index 377f90c..c42a6dd 100644 --- a/bench_traversal_test.go +++ b/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++ { diff --git a/example_test.go b/example_test.go index 36aaba3..f77d368 100644 --- a/example_test.go +++ b/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 diff --git a/expand_test.go b/expand_test.go index 4e8f5ec..89cec8c 100644 --- a/expand_test.go +++ b/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) } diff --git a/filter.go b/filter.go index f0b4bf8..29f5960 100644 --- a/filter.go +++ b/filter.go @@ -70,7 +70,7 @@ func (this *Selection) Intersection(s *Selection) *Selection { // that matches the selector. // It returns a new Selection object with the matching elements. func (this *Selection) Has(selector string) *Selection { - return this.HasSelection(this.document.Root.Find(selector)) + return this.HasSelection(this.document.Find(selector)) } // HasNodes() reduces the set of matched elements to those that have a diff --git a/filter_test.go b/filter_test.go index 9df4661..ac7f91d 100644 --- a/filter_test.go +++ b/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) } diff --git a/iteration_test.go b/iteration_test.go index c6187b5..deac253 100644 --- a/iteration_test.go +++ b/iteration_test.go @@ -8,7 +8,7 @@ import ( func TestEach(t *testing.T) { var cnt int - sel := Doc().Root.Find(".hero-unit .row-fluid").Each(func(i int, n *Selection) { + sel := Doc().Find(".hero-unit .row-fluid").Each(func(i int, n *Selection) { cnt++ t.Logf("At index %v, node %v", i, n.Nodes[0].Data) }).Find("a") @@ -22,7 +22,7 @@ func TestEach(t *testing.T) { func TestEachEmptySelection(t *testing.T) { var cnt int - sel := Doc().Root.Find("zzzz") + sel := Doc().Find("zzzz") sel.Each(func(i int, n *Selection) { cnt++ }) @@ -34,7 +34,7 @@ func TestEachEmptySelection(t *testing.T) { } func TestMap(t *testing.T) { - sel := Doc().Root.Find(".pvk-content") + sel := Doc().Find(".pvk-content") vals := sel.Map(func(i int, s *Selection) string { n := s.Get(0) if n.Type == html.ElementNode { diff --git a/property_test.go b/property_test.go index 80882cb..2dd52b4 100644 --- a/property_test.go +++ b/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) } diff --git a/query_test.go b/query_test.go index ae0c08c..fd9370d 100644 --- a/query_test.go +++ b/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.") } diff --git a/traversal_test.go b/traversal_test.go index fa678d9..bd2e35e 100644 --- a/traversal_test.go +++ b/traversal_test.go @@ -5,574 +5,574 @@ 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) } diff --git a/type.go b/type.go index d98f289..c83bc3e 100644 --- a/type.go +++ b/type.go @@ -12,7 +12,7 @@ import ( // to be told, and that's what the Document class is for. It holds the root // document node to manipulate, and can make selections on this document. type Document struct { - Root *Selection + *Selection Url *url.URL rootNode *html.Node } @@ -49,7 +49,7 @@ func NewDocument(url string) (d *Document, e error) { func newDocument(root *html.Node, url *url.URL) (d *Document) { // Create and fill the document d = &Document{nil, url, root} - d.Root = newSingleSelection(root, d) + d.Selection = newSingleSelection(root, d) return }