├── .github
    └── workflows
    │   └── test.yaml
├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── css.go
├── css_test.go
├── fuzz_test.go
├── go.mod
├── go.sum
├── lex.go
├── lex_test.go
├── parse.go
├── parse_test.go
├── queue.go
├── queue_test.go
└── testdata
    └── fuzz
        ├── FuzzParse
            ├── 771e938e4458e983a736261a702e27c7a414fd660a15b63034f290b146d2f217
            ├── 78c19c977ebc4bbd1a8d570c4661a0bd5803195e4c805f7e32109d930b1ac85b
            └── ee189d6aaeb573cafd396e75348f04c44b83416d61cfca61c8446c5a41317cf8
        └── FuzzSelector
            └── 00e15d22123489fd


/.github/workflows/test.yaml:
--------------------------------------------------------------------------------
 1 | name: test
 2 | on: 
 3 |   push:
 4 |     branches:
 5 |       - main
 6 |   pull_request:
 7 |     branches:
 8 |       - main
 9 | 
10 | jobs:
11 |   test:
12 |     strategy:
13 |       matrix:
14 |         os: [ubuntu-latest]
15 |         go-version: [1.22.x, 1.23.x]
16 |     runs-on: ${{ matrix.os }}
17 |     steps:
18 |     - name: Install Go
19 |       uses: actions/setup-go@v2
20 |       with:
21 |         go-version: ${{ matrix.go-version }}
22 |     - name: Checkout code
23 |       uses: actions/checkout@v2
24 |     - name: Build
25 |       run: go build ./...
26 |     - name: Test
27 |       run: go test -v ./...
28 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | bin/
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2017 Eric Chiang
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | .PHONY: cover
2 | cover:
3 | 	go test -coverprofile=bin/coverage.out
4 | 	go tool cover -html=bin/coverage.out
5 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # CSS selectors in Go
 2 | 
 3 | [![Go Reference](https://pkg.go.dev/badge/github.com/ericchiang/css.svg)](https://pkg.go.dev/github.com/ericchiang/css)
 4 | 
 5 | This package implements a CSS selector compiler for Go's HTML parsing package golang.org/x/net/html.
 6 | 
 7 | ```go
 8 | package main
 9 | 
10 | import (
11 | 	"fmt"
12 | 	"os"
13 | 	"strings"
14 | 
15 | 	"github.com/ericchiang/css"
16 | 	"golang.org/x/net/html"
17 | )
18 | 
19 | var data = `
20 | <p>
21 |   <h2 id="foo">a header</h2>
22 |   <h2 id="bar">another header</h2>
23 | </p>`
24 | 
25 | func main() {
26 | 	sel, err := css.Parse("h2#foo")
27 | 	if err != nil {
28 | 		panic(err)
29 | 	}
30 | 	node, err := html.Parse(strings.NewReader(data))
31 | 	if err != nil {
32 | 		panic(err)
33 | 	}
34 | 	for _, ele := range sel.Select(node) {
35 | 		html.Render(os.Stdout, ele)
36 | 	}
37 | 	fmt.Println()
38 | }
39 | ```
40 | 
41 | ```
42 | $ go run example/css.go
43 | <h2 id="foo">a header</h2>
44 | ```
45 | 


--------------------------------------------------------------------------------
/css.go:
--------------------------------------------------------------------------------
  1 | // Package css implements CSS selector HTML search.
  2 | //
  3 | // Selectors compiled by this package search through golang.org/x/net/html nodes and should
  4 | // be used in conjunction with that package.
  5 | //
  6 | //	data := `<p>
  7 | //		<h2 id="foo">a header</h2>
  8 | //		<h2 id="bar">another header</h2>
  9 | //	</p>`
 10 | //
 11 | //	sel, err := css.Parse("h2#foo")
 12 | //	if err != nil {
 13 | //		// handle error
 14 | //	}
 15 | //	node, err := html.Parse(strings.NewReader(data))
 16 | //	if err != nil {
 17 | //		// handle error
 18 | //	}
 19 | //	elements := sel.Select(node)
 20 | //
 21 | // This package aims to support Selectors Level 4 https://www.w3.org/TR/selectors-4/.
 22 | //
 23 | // The universal selector (*) is supported, along with:
 24 | //
 25 | //	a                       // Type selector
 26 | //	ns|a                    // Type selector with namespace
 27 | //	.red                    // Class selector
 28 | //	#demo                   // ID selector
 29 | //	[attr]                  // Attribute selector
 30 | //	[attr=value]            // Attribute selector value
 31 | //	[attr~=value]           // Attribute selector element of list
 32 | //	[attr|=value]           // Attribute selector value or "{value}-" prefix
 33 | //	[attr^=value]           // Attribute selector prefix
 34 | //	[attr$=value]           // Attribute selector suffix
 35 | //	[attr*=value]           // Attribute selector contains value
 36 | //	[attr=value i]          // Attribute selector case insensitive modifier
 37 | //	foo, bar                // Selector list
 38 | //	foo bar                 // Descendant combinator
 39 | //	foo > bar               // Child combinator
 40 | //	foo ~ bar               // General sibling combinator
 41 | //	foo + bar               // Adjacent sibling combinator
 42 | //	:empty                  // Element with no children
 43 | //	:first-child            // First child of parent
 44 | //	:first-of-type          // First child of its type of parent
 45 | //	:last-child             // Last child of parent
 46 | //	:last-of-type           // Last child of its type of parent
 47 | //	:only-child             // Only child of parent
 48 | //	:only-of-type           // Only child of its type parent
 49 | //	:root                   // Root element
 50 | //	:nth-child(An+B)        // Positional child matcher
 51 | //	:nth-last-child(An+B)   // Reverse positional child matcher
 52 | //	:nth-last-of-type(An+B) // Reverse positional child matcher of type
 53 | //	:nth-of-type(An+B)      // Positional child matcher of type
 54 | package css
 55 | 
 56 | import (
 57 | 	"errors"
 58 | 	"fmt"
 59 | 	"strings"
 60 | 
 61 | 	"golang.org/x/net/html"
 62 | 	"golang.org/x/net/html/atom"
 63 | )
 64 | 
 65 | // ParseError is returned indicating an lex, parse, or compilation error with
 66 | // the associated position in the string the error occurred.
 67 | type ParseError struct {
 68 | 	Pos int
 69 | 	Msg string
 70 | }
 71 | 
 72 | // Error returns a formatted version of the error.
 73 | func (p *ParseError) Error() string {
 74 | 	return fmt.Sprintf("css: %s at position %d", p.Msg, p.Pos)
 75 | }
 76 | 
 77 | func errorf(pos int, msg string, v ...interface{}) error {
 78 | 	return &ParseError{pos, fmt.Sprintf(msg, v...)}
 79 | }
 80 | 
 81 | // Selector is a compiled CSS selector.
 82 | type Selector struct {
 83 | 	s []*selector
 84 | }
 85 | 
 86 | // Select returns any matches from a parsed HTML document.
 87 | func (s *Selector) Select(n *html.Node) []*html.Node {
 88 | 	selected := []*html.Node{}
 89 | 	for _, sel := range s.s {
 90 | 		selected = append(selected, sel.find(n)...)
 91 | 	}
 92 | 	return selected
 93 | }
 94 | 
 95 | func findAll(n *html.Node, fn func(n *html.Node) bool) []*html.Node {
 96 | 	var m []*html.Node
 97 | 	if fn(n) {
 98 | 		m = append(m, n)
 99 | 	}
100 | 	for c := n.FirstChild; c != nil; c = c.NextSibling {
101 | 		if c.Type != html.ElementNode {
102 | 			continue
103 | 		}
104 | 		m = append(m, findAll(c, fn)...)
105 | 	}
106 | 	return m
107 | }
108 | 
109 | // MustParse is like Parse but panics on errors.
110 | func MustParse(s string) *Selector {
111 | 	sel, err := Parse(s)
112 | 	if err != nil {
113 | 		panic(err)
114 | 	}
115 | 	return sel
116 | }
117 | 
118 | // Parse compiles a complex selector list from a string. The parser supports
119 | // Selectors Level 4.
120 | //
121 | // Multiple selectors are supported through comma separated values. For example
122 | // "h1, h2".
123 | //
124 | // Parse reports the first error hit when compiling.
125 | func Parse(s string) (*Selector, error) {
126 | 	p := newParser(s)
127 | 	list, err := p.parse()
128 | 	if err != nil {
129 | 		var perr *parseErr
130 | 		if errors.As(err, &perr) {
131 | 			return nil, &ParseError{perr.t.pos, perr.msg}
132 | 		}
133 | 		var lerr *lexErr
134 | 		if errors.As(err, &lerr) {
135 | 			return nil, &ParseError{lerr.last, lerr.msg}
136 | 		}
137 | 		return nil, err
138 | 	}
139 | 	sel := &Selector{}
140 | 
141 | 	c := compiler{maxErrs: 1}
142 | 	for _, s := range list {
143 | 		m := c.compile(&s)
144 | 		if m == nil {
145 | 			continue
146 | 		}
147 | 		sel.s = append(sel.s, m)
148 | 	}
149 | 	if err := c.err(); err != nil {
150 | 		return nil, err
151 | 	}
152 | 	return sel, nil
153 | }
154 | 
155 | type compiler struct {
156 | 	sels    []complexSelector
157 | 	maxErrs int
158 | 	errs    []error
159 | }
160 | 
161 | func (c *compiler) err() error {
162 | 	if len(c.errs) == 0 {
163 | 		return nil
164 | 	}
165 | 	return c.errs[0]
166 | }
167 | 
168 | func (c *compiler) errorf(pos int, msg string, v ...interface{}) bool {
169 | 	err := &ParseError{pos, fmt.Sprintf(msg, v...)}
170 | 	c.errs = append(c.errs, err)
171 | 	if len(c.errs) >= c.maxErrs {
172 | 		return true
173 | 	}
174 | 	return false
175 | }
176 | 
177 | type combinator interface {
178 | 	find(n *html.Node) []*html.Node
179 | }
180 | 
181 | type selector struct {
182 | 	m *compoundSelectorMatcher
183 | 
184 | 	combinators []combinator
185 | }
186 | 
187 | func (s selector) find(n *html.Node) []*html.Node {
188 | 	nodes := findAll(n, s.m.match)
189 | 	for _, c := range s.combinators {
190 | 		var ns []*html.Node
191 | 		for _, n := range nodes {
192 | 			ns = append(ns, c.find(n)...)
193 | 		}
194 | 		nodes = ns
195 | 	}
196 | 	return nodes
197 | }
198 | 
199 | type descendantCombinator struct {
200 | 	m *compoundSelectorMatcher
201 | }
202 | 
203 | func (c *descendantCombinator) find(n *html.Node) []*html.Node {
204 | 	var nodes []*html.Node
205 | 	for n := n.FirstChild; n != nil; n = n.NextSibling {
206 | 		if n.Type != html.ElementNode {
207 | 			continue
208 | 		}
209 | 		nodes = append(nodes, findAll(n, c.m.match)...)
210 | 	}
211 | 	return nodes
212 | }
213 | 
214 | type childCombinator struct {
215 | 	m *compoundSelectorMatcher
216 | }
217 | 
218 | func (c *childCombinator) find(n *html.Node) []*html.Node {
219 | 	var nodes []*html.Node
220 | 	for n := n.FirstChild; n != nil; n = n.NextSibling {
221 | 		if n.Type != html.ElementNode {
222 | 			continue
223 | 		}
224 | 		if c.m.match(n) {
225 | 			nodes = append(nodes, n)
226 | 		}
227 | 	}
228 | 	return nodes
229 | }
230 | 
231 | type adjacentCombinator struct {
232 | 	m *compoundSelectorMatcher
233 | }
234 | 
235 | func (c *adjacentCombinator) find(n *html.Node) []*html.Node {
236 | 	var (
237 | 		nodes []*html.Node
238 | 		prev  *html.Node
239 | 		next  *html.Node
240 | 	)
241 | 	for prev = n.PrevSibling; prev != nil; prev = prev.PrevSibling {
242 | 		if prev.Type == html.ElementNode {
243 | 			break
244 | 		}
245 | 	}
246 | 	for next = n.NextSibling; next != nil; next = next.NextSibling {
247 | 		if next.Type == html.ElementNode {
248 | 			break
249 | 		}
250 | 	}
251 | 	if prev != nil && c.m.match(prev) {
252 | 		nodes = append(nodes, prev)
253 | 	}
254 | 	if next != nil && c.m.match(next) {
255 | 		nodes = append(nodes, next)
256 | 	}
257 | 	return nodes
258 | }
259 | 
260 | type siblingCombinator struct {
261 | 	m *compoundSelectorMatcher
262 | }
263 | 
264 | func (c *siblingCombinator) find(n *html.Node) []*html.Node {
265 | 	var nodes []*html.Node
266 | 	for n := n.PrevSibling; n != nil; n = n.PrevSibling {
267 | 		if n.Type != html.ElementNode {
268 | 			continue
269 | 		}
270 | 		if c.m.match(n) {
271 | 			nodes = append(nodes, n)
272 | 		}
273 | 	}
274 | 	for n := n.NextSibling; n != nil; n = n.NextSibling {
275 | 		if n.Type != html.ElementNode {
276 | 			continue
277 | 		}
278 | 		if c.m.match(n) {
279 | 			nodes = append(nodes, n)
280 | 		}
281 | 	}
282 | 	return nodes
283 | }
284 | 
285 | func (c *compiler) compile(s *complexSelector) *selector {
286 | 	m := &selector{
287 | 		m: c.compoundSelector(&s.sel),
288 | 	}
289 | 	curr := s
290 | 	for {
291 | 		if curr.next == nil {
292 | 			return m
293 | 		}
294 | 		sel := c.compoundSelector(&curr.next.sel)
295 | 		comb := curr.combinator
296 | 
297 | 		curr = curr.next
298 | 
299 | 		var cm combinator
300 | 		switch comb {
301 | 		case "":
302 | 			cm = &descendantCombinator{sel}
303 | 		case ">":
304 | 			cm = &childCombinator{sel}
305 | 		case "+":
306 | 			cm = &adjacentCombinator{sel}
307 | 		case "~":
308 | 			cm = &siblingCombinator{sel}
309 | 		default:
310 | 			c.errorf(curr.pos, "unexpected combinator: %s", comb)
311 | 			continue
312 | 		}
313 | 		m.combinators = append(m.combinators, cm)
314 | 	}
315 | 	return m
316 | }
317 | 
318 | type compoundSelectorMatcher struct {
319 | 	m   *typeSelectorMatcher
320 | 	scm []subclassSelectorMatcher
321 | }
322 | 
323 | func (c *compoundSelectorMatcher) match(n *html.Node) bool {
324 | 	if c.m != nil {
325 | 		if !c.m.match(n) {
326 | 			return false
327 | 		}
328 | 	}
329 | 	for _, m := range c.scm {
330 | 		if !m.match(n) {
331 | 			return false
332 | 		}
333 | 	}
334 | 	return true
335 | }
336 | 
337 | func (c *compiler) compoundSelector(s *compoundSelector) *compoundSelectorMatcher {
338 | 	m := &compoundSelectorMatcher{}
339 | 	if s.typeSelector != nil {
340 | 		m.m = c.typeSelector(s.typeSelector)
341 | 	}
342 | 	for _, sc := range s.subClasses {
343 | 		scm := c.subclassSelector(&sc)
344 | 		if scm != nil {
345 | 			m.scm = append(m.scm, *scm)
346 | 		}
347 | 	}
348 | 	if len(s.pseudoSelectors) != 0 {
349 | 		// It's not clear that it makes sense for us to support pseudo elements,
350 | 		// since this is more about modifying added elements than selecting elements.
351 | 		//
352 | 		// https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements
353 | 		if c.errorf(s.pos, "pseudo element selectors not supported") {
354 | 			return nil
355 | 		}
356 | 	}
357 | 	return m
358 | }
359 | 
360 | type subclassSelectorMatcher struct {
361 | 	idSelector        string
362 | 	classSelector     string
363 | 	attributeSelector *attributeSelectorMatcher
364 | 	pseudoSelector    func(*html.Node) bool
365 | }
366 | 
367 | func (s *subclassSelectorMatcher) match(n *html.Node) bool {
368 | 	if s.idSelector != "" {
369 | 		for _, a := range n.Attr {
370 | 			if a.Key == "id" && a.Val == s.idSelector {
371 | 				return true
372 | 			}
373 | 		}
374 | 		return false
375 | 	}
376 | 
377 | 	if s.classSelector != "" {
378 | 		for _, a := range n.Attr {
379 | 			if a.Key == "class" {
380 | 				for _, val := range strings.Fields(a.Val) {
381 | 					if val == s.classSelector {
382 | 						return true
383 | 					}
384 | 				}
385 | 			}
386 | 		}
387 | 		return false
388 | 	}
389 | 
390 | 	if s.attributeSelector != nil {
391 | 		return s.attributeSelector.match(n)
392 | 	}
393 | 
394 | 	if s.pseudoSelector != nil {
395 | 		return s.pseudoSelector(n)
396 | 	}
397 | 	return false
398 | }
399 | 
400 | func (c *compiler) subclassSelector(s *subclassSelector) *subclassSelectorMatcher {
401 | 	m := &subclassSelectorMatcher{
402 | 		idSelector:    s.idSelector,
403 | 		classSelector: s.classSelector,
404 | 	}
405 | 	if s.attributeSelector != nil {
406 | 		m.attributeSelector = c.attributeSelector(s.attributeSelector)
407 | 	}
408 | 	if s.pseudoClassSelector != nil {
409 | 		m.pseudoSelector = c.pseudoClassSelector(s.pseudoClassSelector)
410 | 	}
411 | 	return m
412 | }
413 | 
414 | type pseudoClassSelectorMatcher struct {
415 | 	matcher func(*html.Node) bool
416 | }
417 | 
418 | func (c *compiler) pseudoClassSelector(s *pseudoClassSelector) func(*html.Node) bool {
419 | 	// https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes
420 | 	switch s.ident {
421 | 	case "empty":
422 | 		return emptyMatcher
423 | 	case "first-child":
424 | 		return firstChildMatcher
425 | 	case "first-of-type":
426 | 		return firstOfTypeMatcher
427 | 	case "last-child":
428 | 		return lastChildMatcher
429 | 	case "last-of-type":
430 | 		return lastOfTypeMatcher
431 | 	case "only-child":
432 | 		return onlyChildMatcher
433 | 	case "only-of-type":
434 | 		return onlyOfTypeMatcher
435 | 	case "root":
436 | 		return rootMatcher
437 | 	case "":
438 | 	default:
439 | 		c.errorf(s.pos, "unsupported pseudo-class selector: %s", s.ident)
440 | 		return nil
441 | 	}
442 | 
443 | 	switch s.function {
444 | 	case "nth-child(":
445 | 		return c.nthChild(s)
446 | 	case "nth-last-child(":
447 | 		return c.nthLastChild(s)
448 | 	case "nth-last-of-type(":
449 | 		return c.nthLastOfType(s)
450 | 	case "nth-of-type(":
451 | 		return c.nthOfType(s)
452 | 	default:
453 | 		c.errorf(s.pos, "unsupported pseudo-class selector: %s", s.function)
454 | 		return nil
455 | 	}
456 | 
457 | 	return nil
458 | }
459 | 
460 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-child
461 | func (c *compiler) nthChild(s *pseudoClassSelector) func(n *html.Node) bool {
462 | 	nth := c.compileNth(s)
463 | 	if nth == nil {
464 | 		return nil
465 | 	}
466 | 	return func(n *html.Node) bool {
467 | 		var i int64 = 1
468 | 		for s := n.PrevSibling; s != nil; s = s.PrevSibling {
469 | 			if s.Type == html.ElementNode {
470 | 				i++
471 | 			}
472 | 		}
473 | 		return nth.matches(i)
474 | 	}
475 | }
476 | 
477 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-of-type
478 | func (c *compiler) nthOfType(s *pseudoClassSelector) func(n *html.Node) bool {
479 | 	nth := c.compileNth(s)
480 | 	if nth == nil {
481 | 		return nil
482 | 	}
483 | 	return func(n *html.Node) bool {
484 | 		var i int64 = 1
485 | 		for s := n.PrevSibling; s != nil; s = s.PrevSibling {
486 | 			if s.Type == html.ElementNode && s.DataAtom == n.DataAtom {
487 | 				i++
488 | 			}
489 | 		}
490 | 		return nth.matches(i)
491 | 	}
492 | }
493 | 
494 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-last-child
495 | func (c *compiler) nthLastChild(s *pseudoClassSelector) func(n *html.Node) bool {
496 | 	nth := c.compileNth(s)
497 | 	if nth == nil {
498 | 		return nil
499 | 	}
500 | 	return func(n *html.Node) bool {
501 | 		var i int64 = 1
502 | 		for s := n.NextSibling; s != nil; s = s.NextSibling {
503 | 			if s.Type == html.ElementNode {
504 | 				i++
505 | 			}
506 | 		}
507 | 		return nth.matches(i)
508 | 	}
509 | }
510 | 
511 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-last-of-type
512 | func (c *compiler) nthLastOfType(s *pseudoClassSelector) func(n *html.Node) bool {
513 | 	nth := c.compileNth(s)
514 | 	if nth == nil {
515 | 		return nil
516 | 	}
517 | 	return func(n *html.Node) bool {
518 | 		var i int64 = 1
519 | 		for s := n.NextSibling; s != nil; s = s.NextSibling {
520 | 			if s.Type == html.ElementNode && n.DataAtom == s.DataAtom {
521 | 				i++
522 | 			}
523 | 		}
524 | 		return nth.matches(i)
525 | 	}
526 | }
527 | 
528 | // nth holds a computed An+B value for :nth-child() and its associated selectors.
529 | type nth struct {
530 | 	a int64
531 | 	b int64
532 | }
533 | 
534 | func (nth nth) matches(val int64) bool {
535 | 	// Is there a value for "n" given "An+B=val" where "n" is non-negative?
536 | 
537 | 	// An + B = val
538 | 	// An = val - B
539 | 	// n = (val - B) / A
540 | 	if nth.a == 0 {
541 | 		return val == nth.b
542 | 	}
543 | 	return (val-nth.b)%nth.a == 0 && (val-nth.b)/nth.a >= 0
544 | }
545 | 
546 | func (c *compiler) compileNth(s *pseudoClassSelector) *nth {
547 | 	p := newParserFromTokens(s.args)
548 | 	a, err := p.aNPlusB()
549 | 	if err != nil {
550 | 		c.errorf(s.pos, "failed to parse <an+b> expression: %v", err)
551 | 		return nil
552 | 	}
553 | 	if err := p.expectWhitespaceOrEOF(); err != nil {
554 | 		c.errorf(s.pos, "failed to parse <an+b> expression: %v", err)
555 | 		return nil
556 | 	}
557 | 	return a
558 | }
559 | 
560 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:empty
561 | func emptyMatcher(n *html.Node) bool {
562 | 	for c := n.FirstChild; c != nil; c = c.NextSibling {
563 | 		if c.Type == html.ElementNode {
564 | 			return false
565 | 		}
566 | 	}
567 | 	return true
568 | }
569 | 
570 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:first-child
571 | func firstChildMatcher(n *html.Node) bool {
572 | 	for s := n.PrevSibling; s != nil; s = s.PrevSibling {
573 | 		if s.Type == html.ElementNode {
574 | 			return false
575 | 		}
576 | 	}
577 | 	return true
578 | }
579 | 
580 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:first-of-type
581 | func firstOfTypeMatcher(n *html.Node) bool {
582 | 	for s := n.PrevSibling; s != nil; s = s.PrevSibling {
583 | 		if s.Type != html.ElementNode {
584 | 			continue
585 | 		}
586 | 		if s.DataAtom == n.DataAtom {
587 | 			return false
588 | 		}
589 | 	}
590 | 	return true
591 | }
592 | 
593 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:last-child
594 | func lastChildMatcher(n *html.Node) bool {
595 | 	for s := n.NextSibling; s != nil; s = s.NextSibling {
596 | 		if s.Type == html.ElementNode {
597 | 			return false
598 | 		}
599 | 	}
600 | 	return true
601 | }
602 | 
603 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:last-of-type
604 | func lastOfTypeMatcher(n *html.Node) bool {
605 | 	for s := n.NextSibling; s != nil; s = s.NextSibling {
606 | 		if s.Type != html.ElementNode {
607 | 			continue
608 | 		}
609 | 		if s.DataAtom == n.DataAtom {
610 | 			return false
611 | 		}
612 | 	}
613 | 	return true
614 | }
615 | 
616 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:only-child
617 | func onlyChildMatcher(n *html.Node) bool {
618 | 	return firstChildMatcher(n) && lastChildMatcher(n)
619 | }
620 | 
621 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:only-of-type
622 | func onlyOfTypeMatcher(n *html.Node) bool {
623 | 	return firstOfTypeMatcher(n) && lastOfTypeMatcher(n)
624 | }
625 | 
626 | // https://developer.mozilla.org/en-US/docs/Web/CSS/:root
627 | func rootMatcher(n *html.Node) bool {
628 | 	return n.Parent == nil
629 | }
630 | 
631 | type attributeSelectorMatcher struct {
632 | 	ns namespaceMatcher
633 | 	fn func(key, val string) bool
634 | }
635 | 
636 | func (a *attributeSelectorMatcher) match(n *html.Node) bool {
637 | 	for _, attr := range n.Attr {
638 | 		if a.ns.match(attr.Namespace) && a.fn(attr.Key, attr.Val) {
639 | 			return true
640 | 		}
641 | 	}
642 | 	return false
643 | }
644 | 
645 | func (c *compiler) attributeSelector(s *attributeSelector) *attributeSelectorMatcher {
646 | 	m := &attributeSelectorMatcher{
647 | 		ns: newNamespaceMatcher(s.wqName.hasPrefix, s.wqName.prefix),
648 | 	}
649 | 	key := s.wqName.value
650 | 	val := s.val
651 | 
652 | 	if s.modifier {
653 | 		key = strings.ToLower(key)
654 | 		val = strings.ToLower(val)
655 | 	}
656 | 
657 | 	// https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors
658 | 	switch s.matcher {
659 | 	case "=":
660 | 		m.fn = func(k, v string) bool { return k == key && v == val }
661 | 	case "~=":
662 | 		m.fn = func(k, v string) bool {
663 | 			if k != key {
664 | 				return false
665 | 			}
666 | 			for _, f := range strings.Fields(v) {
667 | 				if f == val {
668 | 					return true
669 | 				}
670 | 			}
671 | 			return false
672 | 		}
673 | 	case "|=":
674 | 		// "Represents elements with an attribute name of attr whose value can be
675 | 		// exactly value or can begin with value immediately followed by a hyphen,
676 | 		// - (U+002D). It is often used for language subcode matches."
677 | 		m.fn = func(k, v string) bool {
678 | 			return k == key && (v == val || strings.HasPrefix(v, val+"-"))
679 | 		}
680 | 	case "^=":
681 | 		m.fn = func(k, v string) bool {
682 | 			return k == key && strings.HasPrefix(v, val)
683 | 		}
684 | 	case "$=":
685 | 		m.fn = func(k, v string) bool {
686 | 			return k == key && strings.HasSuffix(v, val)
687 | 		}
688 | 	case "*=":
689 | 		m.fn = func(k, v string) bool {
690 | 			return k == key && strings.Contains(v, val)
691 | 		}
692 | 	case "":
693 | 		m.fn = func(k, v string) bool { return k == key }
694 | 	default:
695 | 		c.errorf(s.pos, "unsupported attribute matcher: %s", s.matcher)
696 | 		return nil
697 | 	}
698 | 	if s.modifier {
699 | 		fn := m.fn
700 | 		m.fn = func(k, v string) bool {
701 | 			k = strings.ToLower(k)
702 | 			v = strings.ToLower(v)
703 | 			return fn(k, v)
704 | 		}
705 | 	}
706 | 	return m
707 | }
708 | 
709 | // namespaceMatcher performs <ns-prefix> matching for elements and attributes.
710 | type namespaceMatcher struct {
711 | 	noNamespace bool
712 | 	namespace   string
713 | }
714 | 
715 | func newNamespaceMatcher(hasPrefix bool, prefix string) namespaceMatcher {
716 | 	if !hasPrefix {
717 | 		return namespaceMatcher{}
718 | 	}
719 | 	if prefix == "" {
720 | 		return namespaceMatcher{noNamespace: true}
721 | 	}
722 | 	if prefix == "*" {
723 | 		return namespaceMatcher{}
724 | 	}
725 | 	return namespaceMatcher{namespace: prefix}
726 | }
727 | 
728 | func (n *namespaceMatcher) match(ns string) bool {
729 | 	if n.noNamespace {
730 | 		return ns == ""
731 | 	}
732 | 	if n.namespace == "" {
733 | 		return true
734 | 	}
735 | 	return n.namespace == ns
736 | }
737 | 
738 | type typeSelectorMatcher struct {
739 | 	allAtoms bool
740 | 	atom     atom.Atom
741 | 	ns       namespaceMatcher
742 | }
743 | 
744 | func (t *typeSelectorMatcher) match(n *html.Node) (ok bool) {
745 | 	if !(t.allAtoms || t.atom == n.DataAtom) {
746 | 		return false
747 | 	}
748 | 	return t.ns.match(n.Namespace)
749 | }
750 | 
751 | func (c *compiler) typeSelector(s *typeSelector) *typeSelectorMatcher {
752 | 	m := &typeSelectorMatcher{}
753 | 	if s.value == "*" {
754 | 		m.allAtoms = true
755 | 	} else {
756 | 		a := atom.Lookup([]byte(s.value))
757 | 		if a == 0 {
758 | 			if c.errorf(s.pos, "unrecognized node name: %s", s.value) {
759 | 				return nil
760 | 			}
761 | 		}
762 | 		m.atom = a
763 | 	}
764 | 	m.ns = newNamespaceMatcher(s.hasPrefix, s.prefix)
765 | 	return m
766 | }
767 | 


--------------------------------------------------------------------------------
/css_test.go:
--------------------------------------------------------------------------------
  1 | package css
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"reflect"
  8 | 	"strings"
  9 | 	"testing"
 10 | 
 11 | 	"github.com/google/go-cmp/cmp"
 12 | 	"golang.org/x/net/html"
 13 | )
 14 | 
 15 | func (s *Selector) String() string {
 16 | 	var b strings.Builder
 17 | 	formatValue(reflect.ValueOf(s), &b, "")
 18 | 	return b.String()
 19 | }
 20 | 
 21 | func formatValue(v reflect.Value, b *strings.Builder, ident string) {
 22 | 	switch v.Kind() {
 23 | 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 24 | 		fmt.Fprintf(b, "%d", v.Int())
 25 | 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 26 | 		fmt.Fprintf(b, "%d", v.Uint())
 27 | 	case reflect.Float32, reflect.Float64:
 28 | 		fmt.Fprintf(b, "%f", v.Float())
 29 | 	case reflect.Bool:
 30 | 		fmt.Fprintf(b, "%t", v.Bool())
 31 | 	case reflect.Array, reflect.Slice:
 32 | 		if v.IsNil() {
 33 | 			b.WriteString("[]")
 34 | 			return
 35 | 		}
 36 | 		fmt.Fprintf(b, "[\n")
 37 | 		for i := 0; i < v.Len(); i++ {
 38 | 			b.WriteString(ident)
 39 | 			b.WriteString("\t")
 40 | 			formatValue(v.Index(i), b, ident+"\t")
 41 | 			fmt.Fprintf(b, ",\n")
 42 | 		}
 43 | 		b.WriteString(ident)
 44 | 		b.WriteString("]")
 45 | 	case reflect.Func:
 46 | 		if v.IsNil() {
 47 | 			b.WriteString("<nil>")
 48 | 			return
 49 | 		}
 50 | 		fmt.Fprintf(b, "<func()>")
 51 | 	case reflect.Interface:
 52 | 		if v.IsNil() {
 53 | 			b.WriteString("<nil>")
 54 | 			return
 55 | 		}
 56 | 		formatValue(v.Elem(), b, ident)
 57 | 	case reflect.Map:
 58 | 		if v.IsNil() {
 59 | 			b.WriteString("<nil>")
 60 | 			return
 61 | 		}
 62 | 		iter := v.MapRange()
 63 | 		fmt.Fprintf(b, "{\n")
 64 | 		for iter.Next() {
 65 | 			b.WriteString(ident)
 66 | 			formatValue(iter.Key(), b, ident+"\n")
 67 | 			fmt.Fprintf(b, ", ")
 68 | 			formatValue(iter.Value(), b, ident)
 69 | 		}
 70 | 		fmt.Fprintf(b, "}")
 71 | 	case reflect.Ptr:
 72 | 		if v.IsNil() {
 73 | 			b.WriteString("<nil>")
 74 | 			return
 75 | 		}
 76 | 		fmt.Fprintf(b, "*")
 77 | 		formatValue(reflect.Indirect(v), b, ident)
 78 | 	case reflect.String:
 79 | 		fmt.Fprintf(b, "%q", v.String())
 80 | 	case reflect.Struct:
 81 | 		t := v.Type()
 82 | 		fmt.Fprintf(b, "%s{\n", t.Name())
 83 | 		for i := 0; i < v.NumField(); i++ {
 84 | 			b.WriteString(ident + "\t")
 85 | 			b.WriteString(t.Field(i).Name)
 86 | 			b.WriteString(": ")
 87 | 			formatValue(v.Field(i), b, ident+"\t")
 88 | 			b.WriteString(",\n")
 89 | 		}
 90 | 		b.WriteString(ident)
 91 | 		b.WriteString("}")
 92 | 	}
 93 | }
 94 | 
 95 | type selectorTest struct {
 96 | 	sel  string
 97 | 	in   string
 98 | 	want []string
 99 | }
100 | 
101 | var selectorTests = []selectorTest{
102 | 	{
103 | 		"a",
104 | 		`<h1><a></a></h1>`,
105 | 		[]string{`<a></a>`},
106 | 	},
107 | 	{
108 | 		"body",
109 | 		`<h1><a></a></h1>`,
110 | 		[]string{`<body><h1><a></a></h1></body>`},
111 | 	},
112 | 	{
113 | 		"body *",
114 | 		`<h1><a></a></h1>`,
115 | 		[]string{`<h1><a></a></h1>`, `<a></a>`},
116 | 	},
117 | 	{
118 | 		"body > *",
119 | 		`<h1><a></a></h1>`,
120 | 		[]string{`<h1><a></a></h1>`},
121 | 	},
122 | 	{
123 | 		"div",
124 | 		`<h1><div><div></div></div></h1>`,
125 | 		[]string{
126 | 			`<div><div></div></div>`,
127 | 			`<div></div>`,
128 | 		},
129 | 	},
130 | 	{
131 | 		"div",
132 | 		`<h1><div></div><div></div></h1>`,
133 | 		[]string{`<div></div>`, `<div></div>`},
134 | 	},
135 | 	{
136 | 		".foo",
137 | 		`<h1><h2 class="foo"></h2><div class="foo"></div><div id="foo"></div></h1>`,
138 | 		[]string{
139 | 			`<h2 class="foo"></h2>`,
140 | 			`<div class="foo"></div>`,
141 | 		},
142 | 	},
143 | 	{
144 | 		".foo",
145 | 		`<h1><h2 class="foo bar"></h2><div class="bar foo"></div><div id="foo"></div></h1>`,
146 | 		[]string{
147 | 			`<h2 class="foo bar"></h2>`,
148 | 			`<div class="bar foo"></div>`,
149 | 		},
150 | 	},
151 | 	{
152 | 		"div.foo",
153 | 		`<h1><h2 class="foo"></h2><div class="foo"></div><div id="foo"></div></h1>`,
154 | 		[]string{`<div class="foo"></div>`},
155 | 	},
156 | 	{
157 | 		"#foo",
158 | 		`<h1><h2 class="foo"></h2><div class="foo"></div><div id="foo"></div></h1>`,
159 | 		[]string{`<div id="foo"></div>`},
160 | 	},
161 | 	{
162 | 		"div#foo",
163 | 		`<h1><h2 class="foo"></h2><div class="foo"></div><div id="foo"></div></h1>`,
164 | 		[]string{`<div id="foo"></div>`},
165 | 	},
166 | 	{
167 | 		"a",
168 | 		`<div><svg xmlns="http://www.w3.org/2000/svg"><a class="foo"></a></svg></div>`,
169 | 		[]string{`<a class="foo"></a>`},
170 | 	},
171 | 	{
172 | 		"*|a",
173 | 		`<div><svg xmlns="http://www.w3.org/2000/svg"><a class="foo"></a></svg></div>`,
174 | 		[]string{`<a class="foo"></a>`},
175 | 	},
176 | 	{
177 | 		"svg|a",
178 | 		`<div><svg xmlns="http://www.w3.org/2000/svg"><a class="foo"></a></svg></div>`,
179 | 		[]string{`<a class="foo"></a>`},
180 | 	},
181 | 	{
182 | 		"|a",
183 | 		`<div><svg xmlns="http://www.w3.org/2000/svg"><a class="foo"></a></svg></div>`,
184 | 		[]string{},
185 | 	},
186 | 	{
187 | 		"other|a",
188 | 		`<div><svg xmlns="http://www.w3.org/2000/svg"><a class="foo"></a></svg></div>`,
189 | 		[]string{},
190 | 	},
191 | 	{
192 | 		"svg|*",
193 | 		`<div><svg xmlns="http://www.w3.org/2000/svg"><a class="foo"></a></svg></div>`,
194 | 		[]string{
195 | 			`<svg xmlns="http://www.w3.org/2000/svg"><a class="foo"></a></svg>`,
196 | 			`<a class="foo"></a>`,
197 | 		},
198 | 	},
199 | 	{
200 | 		"div[class=foo]",
201 | 		`<h1><h2 class="foo"></h2><div class="foo"></div><div id="foo"></div></h1>`,
202 | 		[]string{
203 | 			`<div class="foo"></div>`,
204 | 		},
205 | 	},
206 | 	{
207 | 		"div[class*=o]",
208 | 		`<h1><h2 class="foo"></h2><div class="foo"></div><div id="foo"></div></h1>`,
209 | 		[]string{
210 | 			`<div class="foo"></div>`,
211 | 		},
212 | 	},
213 | 	{
214 | 		"div[class~=foo]",
215 | 		`<h1><h2 class="foo"></h2><div class="bar foo"></div><div id="foo"></div></h1>`,
216 | 		[]string{
217 | 			`<div class="bar foo"></div>`,
218 | 		},
219 | 	},
220 | 	{
221 | 		"div[class|=foo]",
222 | 		`<h1><div class="foo bar"></div><div class="foo"></div><div class="foo-bar"></div></h1>`,
223 | 		[]string{
224 | 			`<div class="foo"></div>`,
225 | 			`<div class="foo-bar"></div>`,
226 | 		},
227 | 	},
228 | 	{
229 | 		"div[class^=foo]",
230 | 		`<h1><div class="bar foo"></div><div class="foo"></div><div class="foo-bar"></div></h1>`,
231 | 		[]string{
232 | 			`<div class="foo"></div>`,
233 | 			`<div class="foo-bar"></div>`,
234 | 		},
235 | 	},
236 | 	{
237 | 		"div[class$=foo]",
238 | 		`<h1><div class="bar foo"></div><div class="foo"></div><div class="foo-bar"></div></h1>`,
239 | 		[]string{
240 | 			`<div class="bar foo"></div>`,
241 | 			`<div class="foo"></div>`,
242 | 		},
243 | 	},
244 | 	{
245 | 		"div[class]",
246 | 		`<h1><div class="bar foo"></div><div class="foo"></div><div class="foo-bar"></div></h1>`,
247 | 		[]string{
248 | 			`<div class="bar foo"></div>`,
249 | 			`<div class="foo"></div>`,
250 | 			`<div class="foo-bar"></div>`,
251 | 		},
252 | 	},
253 | 	{
254 | 		"div[class^=foO i]",
255 | 		`<h1><div class="bar foo"></div><div class="fOo"></div><div class="Foo-bar"></div></h1>`,
256 | 		[]string{
257 | 			`<div class="fOo"></div>`,
258 | 			`<div class="Foo-bar"></div>`,
259 | 		},
260 | 	},
261 | 	{
262 | 		"div a",
263 | 		`
264 | 			<h1>
265 | 				<div>
266 | 					<a href="http://bar"></a>
267 | 				</div>
268 | 				<div>
269 | 					<div>
270 | 						<a href="http://foo"></a>
271 | 					</div>
272 | 				</div>
273 | 				<a href="http://spam"></a>
274 | 			</h1>
275 | 			`,
276 | 		[]string{
277 | 			`<a href="http://bar"></a>`,
278 | 			`<a href="http://foo"></a>`,
279 | 			`<a href="http://foo"></a>`,
280 | 		},
281 | 	},
282 | 	{
283 | 		"div > a",
284 | 		`
285 | 			<h1>
286 | 				<div>
287 | 					<a href="http://bar"></a>
288 | 				</div>
289 | 				<div>
290 | 					<div>
291 | 						<a href="http://foo"></a>
292 | 					</div>
293 | 				</div>
294 | 				<a href="http://spam"></a>
295 | 			</h1>
296 | 			`,
297 | 		[]string{
298 | 			`<a href="http://bar"></a>`,
299 | 			`<a href="http://foo"></a>`,
300 | 		},
301 | 	},
302 | 	{
303 | 		"div + a",
304 | 		`
305 | 			<h1>
306 | 				<div>
307 | 					<a href="http://bar"></a>
308 | 				</div>
309 | 				<a href="http://spam"></a>
310 | 				<p></p>
311 | 				<a href="http://foo"></a>
312 | 			</h1>
313 | 			`,
314 | 		[]string{
315 | 			`<a href="http://spam"></a>`,
316 | 		},
317 | 	},
318 | 	{
319 | 		"div ~ a",
320 | 		`
321 | 			<h1>
322 | 				<div>
323 | 					<a href="http://bar"></a>
324 | 				</div>
325 | 				<a href="http://spam"></a>
326 | 				<p></p>
327 | 				<a href="http://foo"></a>
328 | 			</h1>
329 | 			`,
330 | 		[]string{
331 | 			`<a href="http://spam"></a>`,
332 | 			`<a href="http://foo"></a>`,
333 | 		},
334 | 	},
335 | 	{
336 | 		"body p em", // https://github.com/ericchiang/css/issues/7
337 | 		`
338 | 				<html>
339 | 					<body>
340 | 						<p>
341 | 							<em></em>
342 | 						</p>
343 | 					</body>
344 | 				</html>
345 | 			`,
346 | 		[]string{"<em></em>"},
347 | 	},
348 | 	{
349 | 		"div:empty",
350 | 		`
351 | 				<div class="foo"><p></p></div>
352 | 				<div class="bar">  </div>
353 | 			`,
354 | 		[]string{`<div class="bar">  </div>`},
355 | 	},
356 | 	{
357 | 		":root",
358 | 		`<html><head></head><body></body></html>`,
359 | 		[]string{`<html><head></head><body></body></html>`},
360 | 	},
361 | 	{
362 | 		"div:first-child",
363 | 		`
364 | 			<p></p>
365 | 			<div>
366 | 				<div class="foo"><p></p></div>
367 | 				<div class="bar"><div class="spam"></div></div>
368 | 			</div>
369 | 			<p></p>
370 | 			`,
371 | 		[]string{
372 | 			`<div class="foo"><p></p></div>`,
373 | 			`<div class="spam"></div>`,
374 | 		},
375 | 	},
376 | 	{
377 | 		"div:last-child",
378 | 		`
379 | 			<p></p>
380 | 			<div>
381 | 				<div class="foo"><p></p></div>
382 | 				<div class="bar"><div class="spam"></div></div>
383 | 			</div>
384 | 			<p></p>
385 | 			`,
386 | 		[]string{
387 | 			`<div class="bar"><div class="spam"></div></div>`,
388 | 			`<div class="spam"></div>`,
389 | 		},
390 | 	},
391 | 	{
392 | 		"div:only-child",
393 | 		`
394 | 			<p></p>
395 | 			<div>
396 | 				<div class="foo"><p></p></div>
397 | 				<div class="bar"><div class="spam"></div></div>
398 | 			</div>
399 | 			<p></p>
400 | 			`,
401 | 		[]string{
402 | 			`<div class="spam"></div>`,
403 | 		},
404 | 	},
405 | 	{
406 | 		".test:first-of-type",
407 | 		`
408 | 			<p></p>
409 | 			<div>
410 | 				<p class="test" id="foo"></p>
411 | 				<div class="test" id="foo"></div>
412 | 				<div class="test" id="bar"></div>
413 | 				<p class="test" id="bar"></p>
414 | 				<h1 class="test" id="bar"></h1>
415 | 			</div>
416 | 			<p></p>
417 | 			`,
418 | 		[]string{
419 | 			`<p class="test" id="foo"></p>`,
420 | 			`<div class="test" id="foo"></div>`,
421 | 			`<h1 class="test" id="bar"></h1>`,
422 | 		},
423 | 	},
424 | 	{
425 | 		".test:last-of-type",
426 | 		`
427 | 			<p></p>
428 | 			<div>
429 | 				<p class="test" id="foo"></p>
430 | 				<div class="test" id="foo"></div>
431 | 				<div class="test" id="bar"></div>
432 | 				<p class="test" id="bar"></p>
433 | 				<h1 class="test" id="bar"></h1>
434 | 			</div>
435 | 			<p></p>
436 | 			`,
437 | 		[]string{
438 | 			`<div class="test" id="bar"></div>`,
439 | 			`<p class="test" id="bar"></p>`,
440 | 			`<h1 class="test" id="bar"></h1>`,
441 | 		},
442 | 	},
443 | 	{
444 | 		".test:only-of-type",
445 | 		`
446 | 			<p></p>
447 | 			<div>
448 | 				<p class="test" id="foo"></p>
449 | 				<div class="test" id="foo"></div>
450 | 				<div class="test" id="bar"></div>
451 | 				<p class="test" id="bar"></p>
452 | 				<h1 class="test" id="bar"></h1>
453 | 			</div>
454 | 			<p></p>
455 | 			`,
456 | 		[]string{
457 | 			`<h1 class="test" id="bar"></h1>`,
458 | 		},
459 | 	},
460 | 	{
461 | 		"li:nth-child(2)",
462 | 		`
463 | 			<ul>
464 | 				<li>1</li>
465 | 				<li>2</li>
466 | 				<li>3</li>
467 | 				<li>4</li>
468 | 				<li>5</li>
469 | 				<li>6</li>
470 | 				<li>7</li>
471 | 				<li>8</li>
472 | 			</ul>
473 | 			`,
474 | 		[]string{
475 | 			`<li>2</li>`,
476 | 		},
477 | 	},
478 | 	{
479 | 		"li:nth-child(1n+2)",
480 | 		`
481 | 			<ul>
482 | 				<li>1</li>
483 | 				<li>2</li>
484 | 				<li>3</li>
485 | 				<li>4</li>
486 | 				<li>5</li>
487 | 				<li>6</li>
488 | 				<li>7</li>
489 | 				<li>8</li>
490 | 			</ul>
491 | 			`,
492 | 		[]string{
493 | 			`<li>2</li>`,
494 | 			`<li>3</li>`,
495 | 			`<li>4</li>`,
496 | 			`<li>5</li>`,
497 | 			`<li>6</li>`,
498 | 			`<li>7</li>`,
499 | 			`<li>8</li>`,
500 | 		},
501 | 	},
502 | 	{
503 | 		"li:nth-child(3n)",
504 | 		`
505 | 			<ul>
506 | 				<li>1</li>
507 | 				<li>2</li>
508 | 				<li>3</li>
509 | 				<li>4</li>
510 | 				<li>5</li>
511 | 				<li>6</li>
512 | 				<li>7</li>
513 | 				<li>8</li>
514 | 			</ul>
515 | 			`,
516 | 		[]string{
517 | 			`<li>3</li>`,
518 | 			`<li>6</li>`,
519 | 		},
520 | 	},
521 | 	{
522 | 		"li:nth-child(3n+2)",
523 | 		`
524 | 			<ul>
525 | 				<li>1</li>
526 | 				<li>2</li>
527 | 				<li>3</li>
528 | 				<li>4</li>
529 | 				<li>5</li>
530 | 				<li>6</li>
531 | 				<li>7</li>
532 | 				<li>8</li>
533 | 			</ul>
534 | 			`,
535 | 		[]string{
536 | 			`<li>2</li>`,
537 | 			`<li>5</li>`,
538 | 			`<li>8</li>`,
539 | 		},
540 | 	},
541 | 	{
542 | 		"li:nth-child(3n+ 2)",
543 | 		`
544 | 			<ul>
545 | 				<li>1</li>
546 | 				<li>2</li>
547 | 				<li>3</li>
548 | 				<li>4</li>
549 | 				<li>5</li>
550 | 				<li>6</li>
551 | 				<li>7</li>
552 | 				<li>8</li>
553 | 			</ul>
554 | 			`,
555 | 		[]string{
556 | 			`<li>2</li>`,
557 | 			`<li>5</li>`,
558 | 			`<li>8</li>`,
559 | 		},
560 | 	},
561 | 	{
562 | 		"li:nth-child(3n - 2)",
563 | 		`
564 | 			<ul>
565 | 				<li>1</li>
566 | 				<li>2</li>
567 | 				<li>3</li>
568 | 				<li>4</li>
569 | 				<li>5</li>
570 | 				<li>6</li>
571 | 				<li>7</li>
572 | 				<li>8</li>
573 | 			</ul>
574 | 			`,
575 | 		[]string{
576 | 			`<li>1</li>`,
577 | 			`<li>4</li>`,
578 | 			`<li>7</li>`,
579 | 		},
580 | 	},
581 | 	{
582 | 		"li:nth-child(even)",
583 | 		`
584 | 			<ul>
585 | 				<li>1</li>
586 | 				<li>2</li>
587 | 				<li>3</li>
588 | 				<li>4</li>
589 | 				<li>5</li>
590 | 				<li>6</li>
591 | 				<li>7</li>
592 | 				<li>8</li>
593 | 			</ul>
594 | 			`,
595 | 		[]string{
596 | 			`<li>2</li>`,
597 | 			`<li>4</li>`,
598 | 			`<li>6</li>`,
599 | 			`<li>8</li>`,
600 | 		},
601 | 	},
602 | 	{
603 | 		"li:nth-child(odd)",
604 | 		`
605 | 			<ul>
606 | 				<li>1</li>
607 | 				<li>2</li>
608 | 				<li>3</li>
609 | 				<li>4</li>
610 | 				<li>5</li>
611 | 				<li>6</li>
612 | 				<li>7</li>
613 | 				<li>8</li>
614 | 			</ul>
615 | 			`,
616 | 		[]string{
617 | 			`<li>1</li>`,
618 | 			`<li>3</li>`,
619 | 			`<li>5</li>`,
620 | 			`<li>7</li>`,
621 | 		},
622 | 	},
623 | 	{
624 | 		"li:nth-last-child(2)",
625 | 		`
626 | 			<ul>
627 | 				<li>1</li>
628 | 				<li>2</li>
629 | 				<li>3</li>
630 | 				<li>4</li>
631 | 				<li>5</li>
632 | 				<li>6</li>
633 | 				<li>7</li>
634 | 				<li>8</li>
635 | 			</ul>
636 | 			`,
637 | 		[]string{
638 | 			`<li>7</li>`,
639 | 		},
640 | 	},
641 | 	{
642 | 		"li:nth-last-child(1n+2)",
643 | 		`
644 | 			<ul>
645 | 				<li>1</li>
646 | 				<li>2</li>
647 | 				<li>3</li>
648 | 				<li>4</li>
649 | 				<li>5</li>
650 | 				<li>6</li>
651 | 				<li>7</li>
652 | 				<li>8</li>
653 | 			</ul>
654 | 			`,
655 | 		[]string{
656 | 			`<li>1</li>`,
657 | 			`<li>2</li>`,
658 | 			`<li>3</li>`,
659 | 			`<li>4</li>`,
660 | 			`<li>5</li>`,
661 | 			`<li>6</li>`,
662 | 			`<li>7</li>`,
663 | 		},
664 | 	},
665 | 	{
666 | 		"li:nth-last-child(3n)",
667 | 		`
668 | 			<ul>
669 | 				<li>1</li>
670 | 				<li>2</li>
671 | 				<li>3</li>
672 | 				<li>4</li>
673 | 				<li>5</li>
674 | 				<li>6</li>
675 | 				<li>7</li>
676 | 				<li>8</li>
677 | 			</ul>
678 | 			`,
679 | 		[]string{
680 | 			`<li>3</li>`,
681 | 			`<li>6</li>`,
682 | 		},
683 | 	},
684 | 	{
685 | 		"li:nth-last-child(3n+2)",
686 | 		`
687 | 			<ul>
688 | 				<li>1</li>
689 | 				<li>2</li>
690 | 				<li>3</li>
691 | 				<li>4</li>
692 | 				<li>5</li>
693 | 				<li>6</li>
694 | 				<li>7</li>
695 | 				<li>8</li>
696 | 			</ul>
697 | 			`,
698 | 		[]string{
699 | 			`<li>1</li>`,
700 | 			`<li>4</li>`,
701 | 			`<li>7</li>`,
702 | 		},
703 | 	},
704 | 	{
705 | 		"li:nth-last-child(3n+2)",
706 | 		`
707 | 			<ul>
708 | 				<li>1</li>
709 | 				<li>2</li>
710 | 				<li>3</li>
711 | 				<li>4</li>
712 | 				<li>5</li>
713 | 				<li>6</li>
714 | 				<li>7</li>
715 | 				<li>8</li>
716 | 			</ul>
717 | 			`,
718 | 		[]string{
719 | 			`<li>1</li>`,
720 | 			`<li>4</li>`,
721 | 			`<li>7</li>`,
722 | 		},
723 | 	},
724 | 	{
725 | 		"ul :nth-of-type(3n+2)",
726 | 		`
727 | 			<ul>
728 | 				<p></p>
729 | 				<li>1</li>
730 | 				<p></p>
731 | 				<li>2</li>
732 | 				<li>3</li>
733 | 				<li>4</li>
734 | 				<li>5</li>
735 | 				<li>6</li>
736 | 				<li>7</li>
737 | 				<li>8</li>
738 | 			</ul>
739 | 			`,
740 | 		[]string{
741 | 			`<p></p>`,
742 | 			`<li>2</li>`,
743 | 			`<li>5</li>`,
744 | 			`<li>8</li>`,
745 | 		},
746 | 	},
747 | 	{
748 | 		"ul :nth-last-of-type(3n+2)",
749 | 		`
750 | 			<ul>
751 | 				<p></p>
752 | 				<li>1</li>
753 | 				<p></p>
754 | 				<li>2</li>
755 | 				<li>3</li>
756 | 				<li>4</li>
757 | 				<li>5</li>
758 | 				<li>6</li>
759 | 				<li>7</li>
760 | 				<li>8</li>
761 | 			</ul>
762 | 			`,
763 | 		[]string{
764 | 			`<p></p>`,
765 | 			`<li>1</li>`,
766 | 			`<li>4</li>`,
767 | 			`<li>7</li>`,
768 | 		},
769 | 	},
770 | }
771 | 
772 | func TestSelector(t *testing.T) {
773 | 	for _, test := range selectorTests {
774 | 		s, err := Parse(test.sel)
775 | 		if err != nil {
776 | 			t.Errorf("Parse(%q) failed %v", test.sel, err)
777 | 			continue
778 | 		}
779 | 		root, err := html.Parse(strings.NewReader(test.in))
780 | 		if err != nil {
781 | 			t.Errorf("html.Parse(%q) failed %v", test.in, err)
782 | 			continue
783 | 		}
784 | 
785 | 		// Re-render test case in case the parser is interpeting it differently than
786 | 		// we expect.
787 | 		b := &bytes.Buffer{}
788 | 		if err := html.Render(b, root); err != nil {
789 | 			t.Errorf("Re-rendering input %s: %v", test.in, err)
790 | 			continue
791 | 		}
792 | 		in := b.String()
793 | 
794 | 		got := []string{}
795 | 		for _, n := range s.Select(root) {
796 | 			b := &bytes.Buffer{}
797 | 			if err := html.Render(b, n); err != nil {
798 | 				t.Errorf("Failed to render result of selecting %q from %s: %v", test.sel, in, err)
799 | 				continue
800 | 			}
801 | 			got = append(got, b.String())
802 | 		}
803 | 		if diff := cmp.Diff(test.want, got); diff != "" {
804 | 			t.Errorf("Selecting %q (%s) from %s returned diff (-want, +got): %s", test.sel, s, in, diff)
805 | 		}
806 | 	}
807 | }
808 | 
809 | func TestBadSelector(t *testing.T) {
810 | 	tests := []struct {
811 | 		sel string
812 | 		pos int
813 | 	}{
814 | 		{":nth-child(3+4n)", 0},
815 | 	}
816 | 	for _, test := range tests {
817 | 		_, err := Parse(test.sel)
818 | 		if err == nil {
819 | 			t.Errorf("Expected parsing %s to return error", test.sel)
820 | 			continue
821 | 		}
822 | 		var perr *ParseError
823 | 		if !errors.As(err, &perr) {
824 | 			t.Errorf("Expected parsing %s to return error of type *ParseError, got %T: %v", test.sel, err, err)
825 | 			continue
826 | 		}
827 | 		if test.pos != perr.Pos {
828 | 			t.Errorf("Parsing %s returned unexpected position, got=%d, want=%d", test.sel, perr.Pos, test.pos)
829 | 		}
830 | 	}
831 | }
832 | 


--------------------------------------------------------------------------------
/fuzz_test.go:
--------------------------------------------------------------------------------
 1 | package css
 2 | 
 3 | import (
 4 | 	"strings"
 5 | 	"testing"
 6 | 
 7 | 	"golang.org/x/net/html"
 8 | )
 9 | 
10 | func FuzzParse(f *testing.F) {
11 | 	corpus := []string{
12 | 		"*",
13 | 		"a",
14 | 		"ns|a",
15 | 		".red",
16 | 		"#demo",
17 | 		"[attr]",
18 | 		"[attr=value]",
19 | 		"[herf~=foo]",
20 | 		"[herf|=foo]",
21 | 		"[herf^=foo]",
22 | 		"[herf$=foo]",
23 | 		"[herf*=foo]",
24 | 		"[herf=foo i]",
25 | 		"h1 a",
26 | 		"h1, a",
27 | 		"h1 > a",
28 | 		"h1 ~ a",
29 | 		"h1 + a",
30 | 		"h1:empty",
31 | 		"h1:first-child",
32 | 		"h1:first-of-type",
33 | 		"h1:last-child",
34 | 		"h1:last-of-type",
35 | 		"h1:only-child",
36 | 		"h1:only-of-type",
37 | 		"h1:root",
38 | 		"h1:nth-child(1n + 3)",
39 | 		"h1:nth-child(odd)",
40 | 		"h1:nth-child(even)",
41 | 		"h1:nth-child(1n)",
42 | 		"h1:nth-child(3)",
43 | 		"h1:nth-child(+3)",
44 | 		"h1:last-child(1n + 3)",
45 | 		"h1:last-of-type(1n + 3)",
46 | 		"h1:nth-of-type(1n + 3)",
47 | 	}
48 | 	for _, s := range corpus {
49 | 		f.Add(s)
50 | 	}
51 | 	f.Fuzz(func(t *testing.T, s string) {
52 | 		Parse(s)
53 | 	})
54 | }
55 | 
56 | func FuzzSelector(f *testing.F) {
57 | 	for _, test := range selectorTests {
58 | 		f.Add(test.sel, test.in)
59 | 	}
60 | 	f.Fuzz(func(t *testing.T, sel, in string) {
61 | 		s, err := Parse(sel)
62 | 		if err != nil {
63 | 			t.Skip()
64 | 		}
65 | 		root, err := html.Parse(strings.NewReader(in))
66 | 		if err != nil {
67 | 			t.Skip()
68 | 		}
69 | 		s.Select(root)
70 | 	})
71 | }
72 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/ericchiang/css
2 | 
3 | go 1.15
4 | 
5 | require (
6 | 	github.com/google/go-cmp v0.5.6
7 | 	golang.org/x/net v0.0.0-20211216030914-fe4d6282115f
8 | )
9 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
 1 | github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
 2 | github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 3 | golang.org/x/net v0.0.0-20211216030914-fe4d6282115f h1:hEYJvxw1lSnWIl8X9ofsYMklzaDs90JI2az5YMd4fPM=
 4 | golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 5 | golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 6 | golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 7 | golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 8 | golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 9 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
10 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
11 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
12 | 


--------------------------------------------------------------------------------
/lex.go:
--------------------------------------------------------------------------------
  1 | package css
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"strconv"
  6 | 	"strings"
  7 | 	"unicode/utf8"
  8 | )
  9 | 
 10 | // lexer implements tokenization for CSS selectors. The algorithm follows the
 11 | // spec recommentations.
 12 | //
 13 | // https://www.w3.org/TR/css-syntax-3/#tokenization
 14 | type lexer struct {
 15 | 	s    string
 16 | 	last int
 17 | 	pos  int
 18 | }
 19 | 
 20 | func newLexer(s string) *lexer {
 21 | 	return &lexer{s, 0, 0}
 22 | }
 23 | 
 24 | const eof = 0
 25 | 
 26 | func (l *lexer) peek() rune {
 27 | 	if len(l.s) <= l.pos {
 28 | 		return eof
 29 | 	}
 30 | 	r, _ := utf8.DecodeRuneInString(l.s[l.pos:])
 31 | 	if r == utf8.RuneError {
 32 | 		return eof
 33 | 	}
 34 | 	return r
 35 | }
 36 | 
 37 | func (l *lexer) peekN(n int) rune {
 38 | 	pos := l.pos
 39 | 	var r rune
 40 | 	for i := 0; i <= n; i++ {
 41 | 		r = l.pop()
 42 | 	}
 43 | 	l.pos = pos
 44 | 	return r
 45 | }
 46 | 
 47 | // push is the equivalent of "reconsume the current input code point".
 48 | func (l *lexer) push(r rune) {
 49 | 	l.pos -= utf8.RuneLen(r)
 50 | }
 51 | 
 52 | func (l *lexer) pop() rune {
 53 | 	if len(l.s) <= l.pos {
 54 | 		return eof
 55 | 	}
 56 | 	r, n := utf8.DecodeRuneInString(l.s[l.pos:])
 57 | 	if r == utf8.RuneError {
 58 | 		return eof
 59 | 	}
 60 | 	l.pos += n
 61 | 	return r
 62 | }
 63 | 
 64 | func (l *lexer) popN(n int) {
 65 | 	for i := 0; i < n; i++ {
 66 | 		l.pop()
 67 | 	}
 68 | }
 69 | 
 70 | type tokenType int
 71 | 
 72 | // Create a shorter type aliases so links to csswg.org don't wrap.
 73 | type tt = tokenType
 74 | 
 75 | const (
 76 | 	_                 tt = iota
 77 | 	tokenAtKeyword       // https://drafts.csswg.org/css-syntax-3/#typedef-at-keyword-token
 78 | 	tokenBracketClose    // https://drafts.csswg.org/css-syntax-3/#tokendef-close-square
 79 | 	tokenBracketOpen     // https://drafts.csswg.org/css-syntax-3/#tokendef-open-square
 80 | 	tokenCDC             // https://drafts.csswg.org/css-syntax-3/#typedef-cdc-token
 81 | 	tokenCDO             // https://drafts.csswg.org/css-syntax-3/#typedef-cdo-token
 82 | 	tokenColon           // https://drafts.csswg.org/css-syntax-3/#typedef-colon-token
 83 | 	tokenComma           // https://drafts.csswg.org/css-syntax-3/#typedef-comma-token
 84 | 	tokenCurlyClose      // https://drafts.csswg.org/css-syntax-3/#tokendef-close-curly
 85 | 	tokenCurlyOpen       // https://drafts.csswg.org/css-syntax-3/#tokendef-open-curly
 86 | 	tokenDelim           // https://drafts.csswg.org/css-syntax-3/#typedef-delim-token
 87 | 	tokenDimension       // https://drafts.csswg.org/css-syntax-3/#typedef-dimension-token
 88 | 	tokenEOF             // https://drafts.csswg.org/css-syntax-3/#typedef-eof-token
 89 | 	tokenFunction        // https://drafts.csswg.org/css-syntax-3/#typedef-function-token
 90 | 	tokenHash            // https://drafts.csswg.org/css-syntax-3/#typedef-hash-token
 91 | 	tokenIdent           // https://www.w3.org/TR/css-syntax-3/#typedef-ident-token
 92 | 	tokenNumber          // https://drafts.csswg.org/css-syntax-3/#typedef-number-token
 93 | 	tokenParenClose      // https://drafts.csswg.org/css-syntax-3/#tokendef-close-paren
 94 | 	tokenParenOpen       // https://drafts.csswg.org/css-syntax-3/#tokendef-open-paren
 95 | 	tokenPercent         // https://drafts.csswg.org/css-syntax-3/#typedef-percentage-token
 96 | 	tokenSemicolon       // https://drafts.csswg.org/css-syntax-3/#typedef-semicolon-token
 97 | 	tokenString          // https://drafts.csswg.org/css-syntax-3/#typedef-string-token
 98 | 	tokenURL             // https://drafts.csswg.org/css-syntax-3/#typedef-url-token
 99 | 	tokenWhitespace      // https://drafts.csswg.org/css-syntax-3/#typedef-whitespace-token
100 | )
101 | 
102 | var tokenTypeString = map[tokenType]string{
103 | 	tokenAtKeyword:    "<at-keyword-token>",
104 | 	tokenBracketClose: "<]-token>",
105 | 	tokenBracketOpen:  "<[-token>",
106 | 	tokenCDC:          "<CDC-token>",
107 | 	tokenCDO:          "<CDO-token>",
108 | 	tokenColon:        "<colon-token>",
109 | 	tokenComma:        "<comma-token>",
110 | 	tokenCurlyClose:   "<}-token>",
111 | 	tokenCurlyOpen:    "<{-token>",
112 | 	tokenDelim:        "<delim-token>",
113 | 	tokenDimension:    "<dimension-token>",
114 | 	tokenEOF:          "<eof-token>",
115 | 	tokenFunction:     "<function-token>",
116 | 	tokenHash:         "<hash-token>",
117 | 	tokenIdent:        "<ident-token>",
118 | 	tokenNumber:       "<number-token>",
119 | 	tokenParenClose:   "<)-token>",
120 | 	tokenParenOpen:    "<(-token>",
121 | 	tokenPercent:      "<percentage-token>",
122 | 	tokenSemicolon:    "<semicolon-token>",
123 | 	tokenString:       "<string-token>",
124 | 	tokenURL:          "<url-token>",
125 | 	tokenWhitespace:   "<whitespace-token>",
126 | }
127 | 
128 | func (t tokenType) String() string {
129 | 	if s, ok := tokenTypeString[t]; ok {
130 | 		return s
131 | 	}
132 | 	return fmt.Sprintf("<0x%x-token>", int(t))
133 | }
134 | 
135 | type token struct {
136 | 	typ  tokenType
137 | 	raw  string
138 | 	s    string
139 | 	pos  int
140 | 	flag tokenFlag
141 | 	dim  string // dimension value, set by <dimension-token>
142 | }
143 | 
144 | func (t token) withDim(dim string) token {
145 | 	t.dim = dim
146 | 	return t
147 | }
148 | 
149 | func (t token) withString(s string) token {
150 | 	t.s = s
151 | 	return t
152 | }
153 | 
154 | func (t token) withFlag(flag tokenFlag) token {
155 | 	t.flag = flag
156 | 	return t
157 | }
158 | 
159 | // tokenFlag holds "type flag" information about the token.
160 | type tokenFlag int
161 | 
162 | const (
163 | 	tokenFlagNone tokenFlag = iota
164 | 	tokenFlagInteger
165 | 	tokenFlagID
166 | 	tokenFlagNumber
167 | 	tokenFlagUnrestricted
168 | )
169 | 
170 | var tokenFlagString = map[tokenFlag]string{
171 | 	tokenFlagNone:         "(no flag set)",
172 | 	tokenFlagInteger:      "type=integer",
173 | 	tokenFlagID:           "type=id",
174 | 	tokenFlagNumber:       "type=number",
175 | 	tokenFlagUnrestricted: "type=unrestricted",
176 | }
177 | 
178 | func (t tokenFlag) String() string {
179 | 	if s, ok := tokenFlagString[t]; ok {
180 | 		return s
181 | 	}
182 | 	return fmt.Sprintf("tokenFlag(0x%x)", int(t))
183 | }
184 | 
185 | func (t token) String() string {
186 | 	return fmt.Sprintf("%s %q pos=%d", t.typ, t.s, t.pos)
187 | }
188 | 
189 | func (t token) isDelim(s string) bool {
190 | 	return t.typ == tokenDelim && t.s == s
191 | }
192 | 
193 | func (t token) isIdent(s string) bool {
194 | 	return t.typ == tokenIdent && t.s == s
195 | }
196 | 
197 | type lexErr struct {
198 | 	msg  string
199 | 	last int
200 | 	pos  int
201 | }
202 | 
203 | func (l *lexErr) Error() string {
204 | 	return l.msg
205 | }
206 | 
207 | func (l *lexer) errorf(format string, v ...interface{}) error {
208 | 	return &lexErr{fmt.Sprintf(format, v...), l.last, l.pos}
209 | }
210 | 
211 | func (l *lexer) token(typ tokenType) token {
212 | 	s := l.s[l.last:l.pos]
213 | 	t := token{typ, s, s, l.last, 0, ""}
214 | 	l.last = l.pos
215 | 	return t
216 | }
217 | 
218 | // https://www.w3.org/TR/css-syntax-3/#consume-token
219 | func (l *lexer) next() (token, error) {
220 | 	r := l.pop()
221 | 
222 | 	if isWhitespace(r) {
223 | 		for isWhitespace(l.peek()) {
224 | 			l.pop()
225 | 		}
226 | 		return l.token(tokenWhitespace), nil
227 | 	}
228 | 
229 | 	if isDigit(r) {
230 | 		l.push(r)
231 | 		return l.numericToken()
232 | 	}
233 | 
234 | 	if isNameStart(r) {
235 | 		l.push(r)
236 | 		return l.identLikeToken()
237 | 	}
238 | 
239 | 	switch r {
240 | 	case '"', '\'':
241 | 		return l.string(r)
242 | 	case eof:
243 | 		return l.token(tokenEOF), nil
244 | 	case '#':
245 | 		if isName(l.peek()) || isValidEscape(l.peek(), l.peekN(1)) {
246 | 			var b strings.Builder
247 | 			b.WriteRune(r)
248 | 			if err := l.consumeName(&b); err != nil {
249 | 				return token{}, err
250 | 			}
251 | 			return l.token(tokenHash).withString(b.String()).withFlag(tokenFlagID), nil
252 | 		}
253 | 		return l.token(tokenDelim), nil
254 | 	case '(':
255 | 		return l.token(tokenParenOpen), nil
256 | 	case ')':
257 | 		return l.token(tokenParenClose), nil
258 | 	case '+':
259 | 		if isNumStart(r, l.peek(), l.peekN(1)) {
260 | 			l.push(r)
261 | 			return l.numericToken()
262 | 		}
263 | 		return l.token(tokenDelim), nil
264 | 	case ',':
265 | 		return l.token(tokenComma), nil
266 | 	case '-':
267 | 		if isNumStart(r, l.peek(), l.peekN(1)) {
268 | 			l.push(r)
269 | 			return l.numericToken()
270 | 		}
271 | 		if l.peek() == '-' && l.peekN(1) == '>' {
272 | 			l.popN(2)
273 | 			return l.token(tokenCDC), nil
274 | 		}
275 | 		if isIdentStart(r, l.peek(), l.peekN(1)) {
276 | 			l.push(r)
277 | 			return l.identLikeToken()
278 | 		}
279 | 		return l.token(tokenDelim), nil
280 | 	case '.':
281 | 		if isNumStart(r, l.peek(), l.peekN(1)) {
282 | 			l.push(r)
283 | 			return l.numericToken()
284 | 		}
285 | 		return l.token(tokenDelim), nil
286 | 	case ':':
287 | 		return l.token(tokenColon), nil
288 | 	case ';':
289 | 		return l.token(tokenSemicolon), nil
290 | 	case '<':
291 | 		if l.peek() == '!' && l.peekN(1) == '-' && l.peekN(2) == '-' {
292 | 			l.popN(3)
293 | 			return l.token(tokenCDO), nil
294 | 		}
295 | 		return l.token(tokenDelim), nil
296 | 	case '@':
297 | 		if isIdentStart(l.peek(), l.peekN(1), l.peekN(2)) {
298 | 			var b strings.Builder
299 | 			b.WriteRune(r)
300 | 			if err := l.consumeName(&b); err != nil {
301 | 				return token{}, err
302 | 			}
303 | 			return l.token(tokenAtKeyword).withString(b.String()), nil
304 | 		}
305 | 		return l.token(tokenDelim), nil
306 | 	case '[':
307 | 		return l.token(tokenBracketOpen), nil
308 | 	case '\\':
309 | 		if !isValidEscape(r, l.peek()) {
310 | 			return token{}, l.errorf("invalid escape character")
311 | 		}
312 | 		l.push(r)
313 | 		return l.identLikeToken()
314 | 	case ']':
315 | 		return l.token(tokenBracketClose), nil
316 | 	case '{':
317 | 		return l.token(tokenCurlyOpen), nil
318 | 	case '}':
319 | 		return l.token(tokenCurlyClose), nil
320 | 	}
321 | 	return l.token(tokenDelim), nil
322 | }
323 | 
324 | // https://www.w3.org/TR/css-syntax-3/#consume-a-string-token
325 | func (l *lexer) string(quote rune) (token, error) {
326 | 	var b strings.Builder
327 | 	for {
328 | 		switch r := l.pop(); r {
329 | 		case quote:
330 | 			return l.token(tokenString).withString(b.String()), nil
331 | 		case eof:
332 | 			return token{}, l.errorf("unexpected eof parsing string")
333 | 		case '\n':
334 | 			return token{}, l.errorf("unexpected newline parsing string")
335 | 		case '\\':
336 | 			switch l.peek() {
337 | 			case eof:
338 | 			case '\n':
339 | 				return token{}, l.errorf("unexpected newline after '\\' parsing string")
340 | 			default:
341 | 				if err := l.consumeEscape(&b); err != nil {
342 | 					return token{}, l.errorf("parsing string: %v", err)
343 | 				}
344 | 			}
345 | 		default:
346 | 			b.WriteRune(r)
347 | 		}
348 | 	}
349 | }
350 | 
351 | // https://www.w3.org/TR/css-syntax-3/#consume-an-escaped-code-point
352 | func (l *lexer) consumeEscape(b *strings.Builder) error {
353 | 	r := l.pop()
354 | 	if r == eof {
355 | 		return l.errorf("unexpected newline after escape sequence")
356 | 	}
357 | 	if !isHex(r) {
358 | 		b.WriteRune(r)
359 | 		return nil
360 | 	}
361 | 
362 | 	var hexRune strings.Builder
363 | 	n := 0
364 | 	for {
365 | 		r := l.peek()
366 | 		if isHex(r) {
367 | 			l.pop()
368 | 			n++
369 | 			if n > 5 {
370 | 				return l.errorf("too many hex digits consuming escape sequence")
371 | 			}
372 | 			hexRune.WriteRune(r)
373 | 			continue
374 | 		}
375 | 
376 | 		if isWhitespace(r) {
377 | 			l.pop()
378 | 			continue
379 | 		}
380 | 
381 | 		s := hexRune.String()
382 | 		val, err := strconv.ParseUint(s, 16, 64)
383 | 		if err != nil {
384 | 			return l.errorf("failed to parse hex escape sequence %s: %v", s, err)
385 | 		}
386 | 		b.WriteRune(rune(val))
387 | 		return nil
388 | 	}
389 | }
390 | 
391 | // https://www.w3.org/TR/css-syntax-3/#consume-a-name
392 | func (l *lexer) consumeName(b *strings.Builder) error {
393 | 	for {
394 | 		r := l.peek()
395 | 		if isName(r) {
396 | 			b.WriteRune(l.pop())
397 | 			continue
398 | 		}
399 | 
400 | 		if isValidEscape(r, l.peekN(1)) {
401 | 			l.pop()
402 | 			if err := l.consumeEscape(b); err != nil {
403 | 				return err
404 | 			}
405 | 			continue
406 | 		}
407 | 		return nil
408 | 	}
409 | }
410 | 
411 | // https://www.w3.org/TR/css-syntax-3/#consume-a-numeric-token
412 | func (l *lexer) numericToken() (token, error) {
413 | 	var b strings.Builder
414 | 	f := l.consumeNumber(&b)
415 | 
416 | 	if isIdentStart(l.peek(), l.peekN(1), l.peekN(2)) {
417 | 		var dim strings.Builder
418 | 		if err := l.consumeName(&dim); err != nil {
419 | 			return token{}, err
420 | 		}
421 | 		return l.token(tokenDimension).
422 | 			withString(b.String()).
423 | 			withFlag(f).
424 | 			withDim(dim.String()), nil
425 | 	}
426 | 
427 | 	if l.peek() == '%' {
428 | 		b.WriteRune(l.pop())
429 | 		return l.token(tokenPercent).withString(b.String()).withFlag(tokenFlagNumber), nil
430 | 	}
431 | 	return l.token(tokenNumber).withString(b.String()).withFlag(f), nil
432 | }
433 | 
434 | // https://www.w3.org/TR/css-syntax-3/#consume-an-ident-like-token
435 | func (l *lexer) identLikeToken() (token, error) {
436 | 	var b strings.Builder
437 | 	if l.startsURL(&b) {
438 | 		return l.consumeURL(&b)
439 | 	}
440 | 
441 | 	if err := l.consumeName(&b); err != nil {
442 | 		return token{}, err
443 | 	}
444 | 
445 | 	if l.peek() == '(' {
446 | 		b.WriteRune(l.pop())
447 | 		return l.token(tokenFunction).withString(b.String()), nil
448 | 	}
449 | 
450 | 	return l.token(tokenIdent).withString(b.String()), nil
451 | }
452 | 
453 | func (l *lexer) startsURL(b *strings.Builder) bool {
454 | 	if !(l.peek() == 'u' || l.peek() == 'U') {
455 | 		return false
456 | 	}
457 | 	if !(l.peekN(1) == 'r' || l.peekN(1) == 'R') {
458 | 		return false
459 | 	}
460 | 	if !(l.peekN(2) == 'l' || l.peekN(2) == 'L') {
461 | 		return false
462 | 	}
463 | 	if l.peekN(3) != '(' {
464 | 		return false
465 | 	}
466 | 
467 | 	// Consume up to two characters of whitespace.
468 | 	n := 4
469 | 	for i := 0; i < 2; i++ {
470 | 		if !isWhitespace(l.peekN(n)) {
471 | 			break
472 | 		}
473 | 		n++
474 | 	}
475 | 
476 | 	r1 := l.peekN(n)
477 | 	r2 := l.peekN(n + 1)
478 | 
479 | 	r := r1
480 | 	if isWhitespace(r1) {
481 | 		r = r2
482 | 	}
483 | 	if r == '\'' || r == '"' {
484 | 		return false
485 | 	}
486 | 
487 | 	for i := 0; i < 4; i++ {
488 | 		b.WriteRune(l.pop())
489 | 	}
490 | 	return true
491 | }
492 | 
493 | // https://www.w3.org/TR/css-syntax-3/#consume-a-url-token
494 | func (l *lexer) consumeURL(b *strings.Builder) (token, error) {
495 | 	for isWhitespace(l.peek()) {
496 | 		b.WriteRune(l.pop())
497 | 	}
498 | 
499 | 	for {
500 | 		r := l.pop()
501 | 		switch {
502 | 		case r == ')':
503 | 			b.WriteRune(r)
504 | 			return l.token(tokenURL).withString(b.String()), nil
505 | 		case r == eof:
506 | 			return token{}, l.errorf("unexpected eof parsing URL")
507 | 		case isWhitespace(r):
508 | 			b.WriteRune(r)
509 | 			for isWhitespace(l.peek()) {
510 | 				b.WriteRune(l.pop())
511 | 			}
512 | 			r := l.pop()
513 | 			b.WriteRune(r)
514 | 			if r == ')' {
515 | 				return l.token(tokenURL).withString(b.String()), nil
516 | 			}
517 | 			return token{}, l.errorf("unexpected character parsing URL: %c", r)
518 | 		case r == '\'', r == '"', r == '(', isNonPrintable(r):
519 | 			return token{}, l.errorf("invalid character parsing URL: %c", r)
520 | 		case r == '\\':
521 | 			if !isValidEscape(r, l.peek()) {
522 | 				return token{}, l.errorf("invalid '\\' parsing URL")
523 | 			}
524 | 			if err := l.consumeEscape(b); err != nil {
525 | 				return token{}, l.errorf("invalid escape parsing URL: %v", err)
526 | 			}
527 | 		default:
528 | 			b.WriteRune(r)
529 | 		}
530 | 	}
531 | }
532 | 
533 | // https://www.w3.org/TR/css-syntax-3/#consume-a-number
534 | func (l *lexer) consumeNumber(b *strings.Builder) tokenFlag {
535 | 	// 1. Initially set type to "integer". Let repr be the empty string.
536 | 	f := tokenFlagInteger
537 | 
538 | 	// 2. If the next input code point is U+002B PLUS SIGN (+) or U+002D
539 | 	// HYPHEN-MINUS (-), consume it and append it to repr.
540 | 	if l.peek() == '+' || l.peek() == '-' {
541 | 		b.WriteRune(l.pop())
542 | 	}
543 | 
544 | 	// 3. While the next input code point is a digit, consume it and append
545 | 	// it to repr.
546 | 	for isDigit(l.peek()) {
547 | 		b.WriteRune(l.pop())
548 | 	}
549 | 
550 | 	// 4. If the next 2 input code points are U+002E FULL STOP (.) followed
551 | 	// by a digit, then:
552 | 	if l.peek() == '.' && isDigit(l.peekN(1)) {
553 | 		// Consume them.
554 | 		// Append them to repr.
555 | 		b.WriteRune(l.pop())
556 | 		b.WriteRune(l.pop())
557 | 		f = tokenFlagNumber
558 | 
559 | 		// While the next input code point is a digit, consume it and append
560 | 		// it to repr.
561 | 		for isDigit(l.peek()) {
562 | 			b.WriteRune(l.pop())
563 | 		}
564 | 	}
565 | 
566 | 	r1 := l.peek()
567 | 	r2 := l.peekN(1)
568 | 	r3 := l.peekN(2)
569 | 
570 | 	// 5. If the next 2 or 3 input code points are U+0045 LATIN CAPITAL LETTER
571 | 	// E (E) or U+0065 LATIN SMALL LETTER E (e), optionally followed by U+002D
572 | 	// HYPHEN-MINUS (-) or U+002B PLUS SIGN (+), followed by a digit, then:
573 | 	if r1 == 'E' || r1 == 'e' {
574 | 		// Set type to "number".
575 | 		f = tokenFlagNumber
576 | 		if isDigit(r2) {
577 | 			b.WriteRune(l.pop())
578 | 			b.WriteRune(l.pop())
579 | 
580 | 			for isDigit(l.peek()) {
581 | 				b.WriteRune(l.pop())
582 | 			}
583 | 		} else if (r2 == '+' || r2 == '-') && isDigit(r3) {
584 | 			b.WriteRune(l.pop())
585 | 			b.WriteRune(l.pop())
586 | 			b.WriteRune(l.pop())
587 | 
588 | 			for isDigit(l.peek()) {
589 | 				b.WriteRune(l.pop())
590 | 			}
591 | 		}
592 | 	}
593 | 	return f
594 | }
595 | 
596 | // https://www.w3.org/TR/css-syntax-3/#whitespace
597 | func isWhitespace(r rune) bool {
598 | 	switch r {
599 | 	case '\n', '\t', ' ':
600 | 		return true
601 | 	default:
602 | 		return false
603 | 	}
604 | }
605 | 
606 | // https://www.w3.org/TR/css-syntax-3/#hex-digit
607 | func isHex(r rune) bool {
608 | 	return isDigit(r) || ('A' <= r && r <= 'F') || ('a' <= r && r <= 'f')
609 | }
610 | 
611 | // https://www.w3.org/TR/css-syntax-3/#digit
612 | func isDigit(r rune) bool {
613 | 	return '0' <= r && r <= '9'
614 | }
615 | 
616 | // https://www.w3.org/TR/css-syntax-3/#letter
617 | func isLetter(r rune) bool {
618 | 	return ('A' <= r && r <= 'Z') || ('a' <= r && r <= 'z')
619 | }
620 | 
621 | // https://www.w3.org/TR/css-syntax-3/#non-ascii-code-point
622 | func isNonASCII(r rune) bool {
623 | 	return r > 0x80
624 | }
625 | 
626 | // https://www.w3.org/TR/css-syntax-3/#name-code-point
627 | func isName(r rune) bool {
628 | 	return isNameStart(r) || isDigit(r) || r == '-'
629 | }
630 | 
631 | // https://www.w3.org/TR/css-syntax-3/#name-start-code-point
632 | func isNameStart(r rune) bool {
633 | 	return isLetter(r) || isNonASCII(r) || r == '_'
634 | }
635 | 
636 | // https://www.w3.org/TR/css-syntax-3/#check-if-three-code-points-would-start-a-number
637 | func isNumStart(r1, r2, r3 rune) bool {
638 | 	if r1 == '+' || r1 == '-' {
639 | 		if isDigit(r2) {
640 | 			return true
641 | 		}
642 | 		if r2 == '.' && isDigit(r3) {
643 | 			return true
644 | 		}
645 | 		return false
646 | 	}
647 | 
648 | 	if r1 == '.' {
649 | 		return isDigit(r2)
650 | 	}
651 | 	return isDigit(r1)
652 | }
653 | 
654 | // https://www.w3.org/TR/css-syntax-3/#check-if-two-code-points-are-a-valid-escape
655 | func isValidEscape(r1, r2 rune) bool {
656 | 	if r1 != '\\' {
657 | 		return false
658 | 	}
659 | 	if r2 == '\n' || r2 == eof {
660 | 		return false
661 | 	}
662 | 	return true
663 | }
664 | 
665 | // https://www.w3.org/TR/css-syntax-3/#check-if-three-code-points-would-start-an-identifier
666 | func isIdentStart(r1, r2, r3 rune) bool {
667 | 	if r1 == '-' {
668 | 		if isNameStart(r2) {
669 | 			return true
670 | 		}
671 | 		if isValidEscape(r2, r3) {
672 | 			return true
673 | 		}
674 | 	}
675 | 	if isNameStart(r1) {
676 | 		return true
677 | 	}
678 | 	if r1 == '\\' && isValidEscape(r1, r2) {
679 | 		return true
680 | 	}
681 | 	return false
682 | }
683 | 
684 | func isNonPrintable(r rune) bool {
685 | 	if 0x0 <= r && r <= 0x8 {
686 | 		return true
687 | 	}
688 | 	if r == '\t' {
689 | 		return true
690 | 	}
691 | 	if 0xe <= r && r <= 0x1f {
692 | 		return true
693 | 	}
694 | 	if r == 0x7F {
695 | 		return true
696 | 	}
697 | 	return false
698 | }
699 | 


--------------------------------------------------------------------------------
/lex_test.go:
--------------------------------------------------------------------------------
  1 | package css
  2 | 
  3 | import (
  4 | 	"reflect"
  5 | 	"testing"
  6 | )
  7 | 
  8 | func tok(typ tokenType, s ...string) token {
  9 | 	switch len(s) {
 10 | 	case 1:
 11 | 		return token{typ: typ, raw: s[0], s: s[0]}
 12 | 	case 2:
 13 | 		return token{typ: typ, raw: s[0], s: s[1]}
 14 | 	}
 15 | 	panic("invalid number of arguments")
 16 | }
 17 | 
 18 | func TestLexer(t *testing.T) {
 19 | 	tests := []struct {
 20 | 		s    string
 21 | 		want []token
 22 | 	}{
 23 | 		{
 24 | 			"   ",
 25 | 			[]token{
 26 | 				tok(tokenWhitespace, "   "),
 27 | 			},
 28 | 		},
 29 | 		{
 30 | 			" \t\n",
 31 | 			[]token{
 32 | 				tok(tokenWhitespace, " \t\n"),
 33 | 			},
 34 | 		},
 35 | 		{
 36 | 			" \"hello\" ",
 37 | 			[]token{
 38 | 				tok(tokenWhitespace, " "),
 39 | 				tok(tokenString, "\"hello\"", "hello"),
 40 | 				tok(tokenWhitespace, " "),
 41 | 			},
 42 | 		},
 43 | 		{
 44 | 			` "\{" `,
 45 | 			[]token{
 46 | 				tok(tokenWhitespace, " "),
 47 | 				tok(tokenString, `"\{"`, "{"),
 48 | 				tok(tokenWhitespace, " "),
 49 | 			},
 50 | 		},
 51 | 		{
 52 | 			` "\0af" `,
 53 | 			[]token{
 54 | 				tok(tokenWhitespace, " "),
 55 | 				tok(tokenString, `"\0af"`, "¯"),
 56 | 				tok(tokenWhitespace, " "),
 57 | 			},
 58 | 		},
 59 | 		{
 60 | 			` "\0a f" `,
 61 | 			[]token{
 62 | 				tok(tokenWhitespace, " "),
 63 | 				tok(tokenString, `"\0a f"`, "¯"),
 64 | 				tok(tokenWhitespace, " "),
 65 | 			},
 66 | 		},
 67 | 		{
 68 | 			`# "foo"`,
 69 | 			[]token{
 70 | 				tok(tokenDelim, "#"),
 71 | 				tok(tokenWhitespace, " "),
 72 | 				tok(tokenString, `"foo"`, "foo"),
 73 | 			},
 74 | 		},
 75 | 		{
 76 | 			`#foo`,
 77 | 			[]token{
 78 | 				tok(tokenHash, "#foo").withFlag(tokenFlagID),
 79 | 			},
 80 | 		},
 81 | 		{
 82 | 			`#\0100`,
 83 | 			[]token{
 84 | 				tok(tokenHash, `#\0100`, "#Ā").withFlag(tokenFlagID),
 85 | 			},
 86 | 		},
 87 | 		{
 88 | 			`#foo()`,
 89 | 			[]token{
 90 | 				tok(tokenHash, "#foo").withFlag(tokenFlagID),
 91 | 				tok(tokenParenOpen, "("),
 92 | 				tok(tokenParenClose, ")"),
 93 | 			},
 94 | 		},
 95 | 		{
 96 | 			`+`,
 97 | 			[]token{
 98 | 				tok(tokenDelim, "+"),
 99 | 			},
100 | 		},
101 | 		{
102 | 			`+1`,
103 | 			[]token{
104 | 				tok(tokenNumber, "+1").withFlag(tokenFlagInteger),
105 | 			},
106 | 		},
107 | 		{
108 | 			`+1.1 +1.11e11 +1.11e+11 +`,
109 | 			[]token{
110 | 				tok(tokenNumber, "+1.1").withFlag(tokenFlagNumber),
111 | 				tok(tokenWhitespace, " "),
112 | 				tok(tokenNumber, "+1.11e11").withFlag(tokenFlagNumber),
113 | 				tok(tokenWhitespace, " "),
114 | 				tok(tokenNumber, "+1.11e+11").withFlag(tokenFlagNumber),
115 | 				tok(tokenWhitespace, " "),
116 | 				tok(tokenDelim, "+"),
117 | 			},
118 | 		},
119 | 		{
120 | 			`+1cm`,
121 | 			[]token{
122 | 				tok(tokenDimension, "+1cm").withString("+1").withDim("cm").withFlag(tokenFlagInteger),
123 | 			},
124 | 		},
125 | 		{
126 | 			`+50%`,
127 | 			[]token{
128 | 				tok(tokenPercent, "+50%").withFlag(tokenFlagNumber),
129 | 			},
130 | 		},
131 | 		{
132 | 			`,`,
133 | 			[]token{
134 | 				tok(tokenComma, ","),
135 | 			},
136 | 		},
137 | 		{
138 | 			`-1.1 -1.11e11 --> -1.11e-11 -`,
139 | 			[]token{
140 | 				tok(tokenNumber, "-1.1").withFlag(tokenFlagNumber),
141 | 				tok(tokenWhitespace, " "),
142 | 				tok(tokenNumber, "-1.11e11").withFlag(tokenFlagNumber),
143 | 				tok(tokenWhitespace, " "),
144 | 				tok(tokenCDC, "-->"),
145 | 				tok(tokenWhitespace, " "),
146 | 				tok(tokenNumber, "-1.11e-11").withFlag(tokenFlagNumber),
147 | 				tok(tokenWhitespace, " "),
148 | 				tok(tokenDelim, "-"),
149 | 			},
150 | 		},
151 | 		{
152 | 			`.1 .11e11 .11e-11 .`,
153 | 			[]token{
154 | 				tok(tokenNumber, ".1").withFlag(tokenFlagNumber),
155 | 				tok(tokenWhitespace, " "),
156 | 				tok(tokenNumber, ".11e11").withFlag(tokenFlagNumber),
157 | 				tok(tokenWhitespace, " "),
158 | 				tok(tokenNumber, ".11e-11").withFlag(tokenFlagNumber),
159 | 				tok(tokenWhitespace, " "),
160 | 				tok(tokenDelim, "."),
161 | 			},
162 | 		},
163 | 		{
164 | 			`:;`,
165 | 			[]token{
166 | 				tok(tokenColon, ":"),
167 | 				tok(tokenSemicolon, ";"),
168 | 			},
169 | 		},
170 | 		{
171 | 			`< <!--`,
172 | 			[]token{
173 | 				tok(tokenDelim, "<"),
174 | 				tok(tokenWhitespace, " "),
175 | 				tok(tokenCDO, "<!--"),
176 | 			},
177 | 		},
178 | 		{
179 | 			`@ @foo @-bar`,
180 | 			[]token{
181 | 				tok(tokenDelim, "@"),
182 | 				tok(tokenWhitespace, " "),
183 | 				tok(tokenAtKeyword, "@foo"),
184 | 				tok(tokenWhitespace, " "),
185 | 				tok(tokenAtKeyword, "@-bar"),
186 | 			},
187 | 		},
188 | 		{
189 | 			`[]{}`,
190 | 			[]token{
191 | 				tok(tokenBracketOpen, "["),
192 | 				tok(tokenBracketClose, "]"),
193 | 				tok(tokenCurlyOpen, "{"),
194 | 				tok(tokenCurlyClose, "}"),
195 | 			},
196 | 		},
197 | 		{
198 | 			`4.123e-2`,
199 | 			[]token{
200 | 				tok(tokenNumber, "4.123e-2").withFlag(tokenFlagNumber),
201 | 			},
202 | 		},
203 | 		{
204 | 			`foo bar(`,
205 | 			[]token{
206 | 				tok(tokenIdent, "foo"),
207 | 				tok(tokenWhitespace, " "),
208 | 				tok(tokenFunction, "bar("),
209 | 			},
210 | 		},
211 | 		{
212 | 			`url(foo) url( foo ) url url("foo")`,
213 | 			[]token{
214 | 				tok(tokenURL, "url(foo)"),
215 | 				tok(tokenWhitespace, " "),
216 | 				tok(tokenURL, "url( foo )"),
217 | 				tok(tokenWhitespace, " "),
218 | 				tok(tokenIdent, "url"),
219 | 				tok(tokenWhitespace, " "),
220 | 				tok(tokenFunction, "url("),
221 | 				tok(tokenString, "\"foo\"", "foo"),
222 | 				tok(tokenParenClose, ")"),
223 | 			},
224 | 		},
225 | 		{
226 | 			`*`,
227 | 			[]token{
228 | 				tok(tokenDelim, "*"),
229 | 			},
230 | 		},
231 | 		{
232 | 			`.foo`,
233 | 			[]token{
234 | 				tok(tokenDelim, "."),
235 | 				tok(tokenIdent, "foo"),
236 | 			},
237 | 		},
238 | 		{
239 | 			`4n`,
240 | 			[]token{
241 | 				tok(tokenDimension, "4n").withString("4").withDim("n").withFlag(tokenFlagInteger),
242 | 			},
243 | 		},
244 | 		{
245 | 			`+n`,
246 | 			[]token{
247 | 				tok(tokenDelim, "+"),
248 | 				tok(tokenIdent, "n"),
249 | 			},
250 | 		},
251 | 		{
252 | 			`n`,
253 | 			[]token{
254 | 				tok(tokenIdent, "n"),
255 | 			},
256 | 		},
257 | 		{
258 | 			`-n`,
259 | 			[]token{
260 | 				tok(tokenIdent, "-n"),
261 | 			},
262 | 		},
263 | 		{
264 | 			`-n-3`,
265 | 			[]token{
266 | 				tok(tokenIdent, "-n-3"),
267 | 			},
268 | 		},
269 | 		{
270 | 			`-n- 3`,
271 | 			[]token{
272 | 				tok(tokenIdent, "-n-"),
273 | 				tok(tokenWhitespace, " "),
274 | 				tok(tokenNumber, "3").withFlag(tokenFlagInteger),
275 | 			},
276 | 		},
277 | 	}
278 | 
279 | L:
280 | 	for _, test := range tests {
281 | 		test.want = append(test.want, tok(tokenEOF, ""))
282 | 
283 | 		pos := 0
284 | 		for i, t := range test.want {
285 | 			t.pos = pos
286 | 			pos = t.pos + len(t.raw)
287 | 			test.want[i] = t
288 | 		}
289 | 
290 | 		var got []token
291 | 		l := newLexer(test.s)
292 | 
293 | 		for {
294 | 			tok, err := l.next()
295 | 			if err != nil {
296 | 				t.Errorf("tokenize selector %q: %v", test.s, err)
297 | 				continue L
298 | 			}
299 | 			got = append(got, tok)
300 | 			if tok.typ == tokenEOF {
301 | 				break
302 | 			}
303 | 		}
304 | 
305 | 		if diff := cmpDiff(test.want, got); diff != "" {
306 | 			t.Errorf("tokenize selector %q returned diff (-want, +got): %s", test.s, diff)
307 | 		}
308 | 	}
309 | }
310 | 
311 | func TestLexerErr(t *testing.T) {
312 | 	tests := []string{
313 | 		"\"\\\n\"",        // Escape sequence is followed by a newline.
314 | 		"\"\\000000000\"", // Escape sequence contains too many hex characters.
315 | 		"\\",              // Invalid escape.
316 | 		"\"",              // Unclosed string.
317 | 		"\"\n\"",          // Newline in string.
318 | 		"url(foo",         // URL hits EOF.
319 | 		"url(foo())",      // URL hits '('.
320 | 	}
321 | 
322 | 	for _, test := range tests {
323 | 		l := newLexer(test)
324 | 		for {
325 | 			tok, err := l.next()
326 | 			if err != nil {
327 | 				break
328 | 			}
329 | 			if tok.typ == tokenEOF {
330 | 				t.Errorf("expected error parsing %q", test)
331 | 				break
332 | 			}
333 | 		}
334 | 	}
335 | }
336 | 
337 | func TestLexerPop(t *testing.T) {
338 | 	tests := []struct {
339 | 		s    string
340 | 		want []rune
341 | 	}{
342 | 		{
343 | 			"hello, world!",
344 | 			[]rune{'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!'},
345 | 		},
346 | 		{
347 | 			"hello, 世界!",
348 | 			[]rune{'h', 'e', 'l', 'l', 'o', ',', ' ', '世', '界', '!'},
349 | 		},
350 | 	}
351 | 
352 | 	for _, test := range tests {
353 | 		var got []rune
354 | 		l := newLexer(test.s)
355 | 		for l.peek() != eof {
356 | 			got = append(got, l.pop())
357 | 		}
358 | 		if !reflect.DeepEqual(got, test.want) {
359 | 			t.Errorf("lexer parsing code points for %q: got=%v, want=%v", test.s, got, test.want)
360 | 		}
361 | 	}
362 | }
363 | 


--------------------------------------------------------------------------------
/parse.go:
--------------------------------------------------------------------------------
  1 | package css
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"strconv"
  6 | 	"strings"
  7 | )
  8 | 
  9 | type parseErr struct {
 10 | 	msg string
 11 | 	t   token
 12 | }
 13 | 
 14 | func (p *parseErr) Error() string {
 15 | 	return fmt.Sprintf("consuming %s: %s", p.t, p.msg)
 16 | }
 17 | 
 18 | type parser struct {
 19 | 	l interface {
 20 | 		next() (token, error)
 21 | 	}
 22 | 	// peekQueue holds tokens that have been peeked but not consumed. These are
 23 | 	// consumed before the lexer is consulted.
 24 | 	peekQueue *queue
 25 | 	// err is set whenever a lex error occurs. When set, all subsequent calls to
 26 | 	// next(), peek(), and peekN() will fail.
 27 | 	err error
 28 | }
 29 | 
 30 | type tokens struct {
 31 | 	i int
 32 | 	t []token
 33 | }
 34 | 
 35 | func (t *tokens) next() (token, error) {
 36 | 	if t.i < len(t.t) {
 37 | 		tok := t.t[t.i]
 38 | 		t.i++
 39 | 		return tok, nil
 40 | 	}
 41 | 	lastPos := 0
 42 | 	if len(t.t) > 0 {
 43 | 		lastTok := t.t[len(t.t)-1]
 44 | 		lastPos = lastTok.pos + len(lastTok.raw)
 45 | 	}
 46 | 	return token{tokenEOF, "", "", lastPos, 0, ""}, nil
 47 | }
 48 | 
 49 | // newParserFromTokens allows creating a parser from a token stream. This is
 50 | // used for subparsers, such as pseudo-elements.
 51 | func newParserFromTokens(t []token) *parser {
 52 | 	return &parser{l: &tokens{t: t}, peekQueue: newQueue(2)}
 53 | }
 54 | 
 55 | func newParser(s string) *parser {
 56 | 	return &parser{l: newLexer(s), peekQueue: newQueue(2)}
 57 | }
 58 | 
 59 | func (p *parser) peek() (token, error) {
 60 | 	return p.peekN(0)
 61 | }
 62 | 
 63 | func (p *parser) peekN(n int) (token, error) {
 64 | 	if p.err != nil {
 65 | 		return token{}, p.err
 66 | 	}
 67 | 	for n >= p.peekQueue.len() {
 68 | 		t, err := p.l.next()
 69 | 		if err != nil {
 70 | 			p.err = err
 71 | 			return token{}, err
 72 | 		}
 73 | 		p.peekQueue.push(t)
 74 | 	}
 75 | 	return p.peekQueue.get(n), nil
 76 | }
 77 | 
 78 | func (p *parser) next() (token, error) {
 79 | 	if p.err != nil {
 80 | 		return token{}, p.err
 81 | 	}
 82 | 	if p.peekQueue.len() > 0 {
 83 | 		return p.peekQueue.pop(), nil
 84 | 	}
 85 | 	t, err := p.l.next()
 86 | 	if err != nil {
 87 | 		p.err = err
 88 | 		return t, err
 89 | 	}
 90 | 	return t, nil
 91 | }
 92 | 
 93 | func (p *parser) errorf(t token, msg string, v ...interface{}) error {
 94 | 	return &parseErr{fmt.Sprintf(msg, v...), t}
 95 | }
 96 | 
 97 | func (p *parser) parse() ([]complexSelector, error) {
 98 | 	var sels []complexSelector
 99 | 	p.skipWhitespace()
100 | 	for {
101 | 		cs, err := p.complexSelector()
102 | 		if err != nil {
103 | 			return nil, err
104 | 		}
105 | 		sels = append(sels, *cs)
106 | 		p.skipWhitespace()
107 | 		t, err := p.next()
108 | 		if err != nil {
109 | 			return nil, err
110 | 		}
111 | 		if t.typ == tokenEOF {
112 | 			return sels, nil
113 | 		}
114 | 		if t.typ != tokenComma {
115 | 			return nil, p.errorf(t, "expected ',' or EOF")
116 | 		}
117 | 		p.skipWhitespace()
118 | 	}
119 | }
120 | 
121 | type complexSelector struct {
122 | 	pos        int
123 | 	sel        compoundSelector
124 | 	combinator string
125 | 	next       *complexSelector
126 | }
127 | 
128 | func (p *parser) complexSelector() (*complexSelector, error) {
129 | 	t, err := p.peek() // peek the first token for creating errors.
130 | 	if err != nil {
131 | 		return nil, err
132 | 	}
133 | 
134 | 	sel := &complexSelector{pos: t.pos}
135 | 	cs, ok, err := p.compoundSelector()
136 | 	if err != nil {
137 | 		return nil, err
138 | 	}
139 | 	if !ok {
140 | 		//  <compound-selector> can start with:
141 | 		//  |-- <type-selector>
142 | 		//  | \-- <ns-prefix>? [ '*' | <ident-token> ]
143 | 		//  |   \-- [ <ident-token> | '*' ]? '|'
144 | 		//  |-- <subclass-selector>
145 | 		//  | |-- <id-selector> = <hash-token>
146 | 		//  | |-- <class-selector> = '.' <ident-token>
147 | 		//  | |-- <attribute-selector> = '[' ...
148 | 		//  | \-- <pseudo-class-selector> = ':' ...
149 | 		//  \-- <pseudo-element-selector> = ':' ...
150 | 		return nil, p.errorf(t, "expected identifier, '#', '*', '.', '|', '[', ':'")
151 | 	}
152 | 	sel.sel = *cs
153 | 
154 | 	last := sel
155 | 	for {
156 | 		p.skipWhitespace()
157 | 		t, err = p.peek()
158 | 		if err != nil {
159 | 			return nil, err
160 | 		}
161 | 		if t.typ == tokenDelim {
162 | 			switch t.s {
163 | 			case ">", "+", "~":
164 | 				p.next()
165 | 				p.skipWhitespace()
166 | 				last.combinator = t.s
167 | 				if t, err = p.peek(); err != nil {
168 | 					return nil, err
169 | 				}
170 | 			case "|":
171 | 				t, err = p.peekN(1)
172 | 				if err != nil {
173 | 					return nil, err
174 | 				}
175 | 				if t.isDelim("|") {
176 | 					p.next()
177 | 					p.next()
178 | 					p.skipWhitespace()
179 | 					last.combinator = "||"
180 | 					if t, err = p.peek(); err != nil {
181 | 						return nil, err
182 | 					}
183 | 				}
184 | 			}
185 | 		}
186 | 		s, ok, err := p.compoundSelector()
187 | 		if err != nil {
188 | 			return nil, err
189 | 		}
190 | 		if !ok {
191 | 			if last.combinator != "" {
192 | 				return nil, p.errorf(t, "expected identifier, '#', '*', '.', '|', '[', ':'")
193 | 			}
194 | 			return sel, nil
195 | 		}
196 | 		next := &complexSelector{pos: s.pos, sel: *s}
197 | 		last.next = next
198 | 		last = next
199 | 	}
200 | }
201 | 
202 | type compoundSelector struct {
203 | 	pos             int
204 | 	typeSelector    *typeSelector // may be nil
205 | 	subClasses      []subclassSelector
206 | 	pseudoSelectors []pseudoSelector
207 | }
208 | 
209 | // <compound-selector> = [ <type-selector>? <subclass-selector>*
210 | //                         [ <pseudo-element-selector> <pseudo-class-selector>* ]* ]!
211 | //
212 | // Whitespace is disallowed between top level elements.
213 | func (p *parser) compoundSelector() (*compoundSelector, bool, error) {
214 | 	t, err := p.peek()
215 | 	if err != nil {
216 | 		return nil, false, err
217 | 	}
218 | 	found := false
219 | 	cs := &compoundSelector{pos: t.pos}
220 | 	ts, ok, err := p.typeSelector()
221 | 	if err != nil {
222 | 		return nil, false, err
223 | 	}
224 | 	if ok {
225 | 		found = true
226 | 		cs.typeSelector = ts
227 | 	}
228 | 	for {
229 | 		sc, ok, err := p.subclassSelector()
230 | 		if err != nil {
231 | 			return nil, false, err
232 | 		}
233 | 		if !ok {
234 | 			break
235 | 		}
236 | 		found = true
237 | 		cs.subClasses = append(cs.subClasses, *sc)
238 | 	}
239 | 	for {
240 | 		ps, ok, err := p.pseudoSelector()
241 | 		if err != nil {
242 | 			return nil, false, err
243 | 		}
244 | 		if !ok {
245 | 			break
246 | 		}
247 | 		found = true
248 | 		cs.pseudoSelectors = append(cs.pseudoSelectors, *ps)
249 | 	}
250 | 	if !found {
251 | 		return nil, false, nil
252 | 	}
253 | 	return cs, true, nil
254 | }
255 | 
256 | type pseudoSelector struct {
257 | 	element pseudoClassSelector
258 | 	classes []pseudoClassSelector
259 | }
260 | 
261 | // Implements a subset of the <compound-selector> logic.
262 | //
263 | // <pseudo-element-selector> <pseudo-class-selector>*
264 | func (p *parser) pseudoSelector() (*pseudoSelector, bool, error) {
265 | 	t, err := p.peek()
266 | 	if err != nil {
267 | 		return nil, false, err
268 | 	}
269 | 	if t.typ != tokenColon {
270 | 		return nil, false, nil
271 | 	}
272 | 	t, err = p.peekN(1)
273 | 	if err != nil {
274 | 		return nil, false, err
275 | 	}
276 | 	if t.typ != tokenColon {
277 | 		return nil, false, nil
278 | 	}
279 | 	p.next()
280 | 
281 | 	ele, err := p.pseudoClassSelector()
282 | 	if err != nil {
283 | 		return nil, false, err
284 | 	}
285 | 	ps := &pseudoSelector{element: *ele}
286 | 	for {
287 | 		p.skipWhitespace()
288 | 		t, err := p.peek()
289 | 		if err != nil {
290 | 			return nil, false, err
291 | 		}
292 | 		if t.typ != tokenColon {
293 | 			return ps, true, nil
294 | 		}
295 | 		cs, err := p.pseudoClassSelector()
296 | 		if err != nil {
297 | 			return nil, false, err
298 | 		}
299 | 		ps.classes = append(ps.classes, *cs)
300 | 	}
301 | }
302 | 
303 | type typeSelector struct {
304 | 	pos       int
305 | 	hasPrefix bool
306 | 	prefix    string
307 | 	value     string
308 | }
309 | 
310 | // <type-selector> = <wq-name> | <ns-prefix>? '*'
311 | // <wq-name> = <ns-prefix>? <ident-token>
312 | // <ns-prefix> = [ <ident-token> | '*' ]? '|'
313 | //
314 | // Whitespace is disallowed.
315 | func (p *parser) typeSelector() (*typeSelector, bool, error) {
316 | 	t, err := p.peek()
317 | 	if err != nil {
318 | 		return nil, false, err
319 | 	}
320 | 	if !(t.typ == tokenIdent || t.isDelim("*") || t.isDelim("|")) {
321 | 		return nil, false, nil
322 | 	}
323 | 
324 | 	name, err := p.parseName(true)
325 | 	if err != nil {
326 | 		return nil, false, err
327 | 	}
328 | 	return &typeSelector{
329 | 		pos:       t.pos,
330 | 		hasPrefix: name.hasPrefix,
331 | 		prefix:    name.prefix,
332 | 		value:     name.value,
333 | 	}, true, nil
334 | }
335 | 
336 | type subclassSelector struct {
337 | 	pos                 int
338 | 	idSelector          string
339 | 	classSelector       string
340 | 	attributeSelector   *attributeSelector
341 | 	pseudoClassSelector *pseudoClassSelector
342 | }
343 | 
344 | // <subclass-selector> = <id-selector> | <class-selector> |
345 | //                       <attribute-selector> | <pseudo-class-selector>
346 | // https://www.w3.org/TR/selectors-4/#typedef-subclass-selector
347 | func (p *parser) subclassSelector() (*subclassSelector, bool, error) {
348 | 	t, err := p.peek()
349 | 	if err != nil {
350 | 		return nil, false, err
351 | 	}
352 | 	ss := &subclassSelector{pos: t.pos}
353 | 	// <id-selector> = <hash-token>
354 | 	if t.typ == tokenHash {
355 | 		p.next()
356 | 		ss.idSelector = strings.TrimPrefix(t.s, "#")
357 | 		return ss, true, nil
358 | 	}
359 | 
360 | 	// <class-selector> = '.' <ident-token>
361 | 	if t.isDelim(".") {
362 | 		p.next()
363 | 		t, err := p.next()
364 | 		if err != nil {
365 | 			return nil, false, err
366 | 		}
367 | 		if t.typ != tokenIdent {
368 | 			return nil, false, p.errorf(t, "expected identifier")
369 | 		}
370 | 		ss.classSelector = strings.TrimPrefix(t.s, ".")
371 | 		return ss, true, nil
372 | 	}
373 | 
374 | 	// <attribute-selector> = '[' <wq-name> ']' | ...
375 | 	if t.typ == tokenBracketOpen {
376 | 		a, err := p.attributeSelector()
377 | 		if err != nil {
378 | 			return nil, false, err
379 | 		}
380 | 		ss.attributeSelector = a
381 | 		return ss, true, nil
382 | 	}
383 | 
384 | 	if t.typ != tokenColon {
385 | 		return nil, false, nil
386 | 	}
387 | 
388 | 	// Maybe a <pseudo-class-selector>? When parsing <subclass-selector> we could
389 | 	// potentially match a <pseudo-element-selector> instead. So if the next
390 | 	// token is ':', assume we've hit a <pseudo-element-selector> and stop.
391 | 	//
392 | 	// <compound-selector> = [ <type-selector>? <subclass-selector>*
393 | 	//                       [ <pseudo-element-selector> <pseudo-class-selector>* ]* ]!
394 | 
395 | 	pt, err := p.peekN(1)
396 | 	if err != nil {
397 | 		return nil, false, err
398 | 	}
399 | 	if pt.typ == tokenColon {
400 | 		// Found a <pseudo-element-selector>.
401 | 		return nil, false, nil
402 | 	}
403 | 	pcs, err := p.pseudoClassSelector()
404 | 	if err != nil {
405 | 		return nil, false, err
406 | 	}
407 | 	ss.pseudoClassSelector = pcs
408 | 	return ss, true, nil
409 | }
410 | 
411 | type pseudoClassSelector struct {
412 | 	pos      int
413 | 	ident    string
414 | 	function string
415 | 	args     []token
416 | }
417 | 
418 | // https://www.w3.org/TR/selectors-4/#typedef-pseudo-class-selector
419 | func (p *parser) pseudoClassSelector() (*pseudoClassSelector, error) {
420 | 	t, err := p.next()
421 | 	if err != nil {
422 | 		return nil, err
423 | 	}
424 | 	pos := t.pos
425 | 	if t.typ != tokenColon {
426 | 		return nil, p.errorf(t, "expected ':'")
427 | 	}
428 | 
429 | 	t, err = p.next()
430 | 	if err != nil {
431 | 		return nil, err
432 | 	}
433 | 	if t.typ == tokenIdent {
434 | 		return &pseudoClassSelector{pos: pos, ident: t.s}, nil
435 | 	}
436 | 	if t.typ != tokenFunction {
437 | 		return nil, p.errorf(t, "expected identifier or function")
438 | 	}
439 | 
440 | 	args, err := p.any(tokenParenClose)
441 | 	if err != nil {
442 | 		return nil, err
443 | 	}
444 | 
445 | 	c, err := p.next()
446 | 	if err != nil {
447 | 		return nil, err
448 | 	}
449 | 	if c.typ != tokenParenClose {
450 | 		return nil, p.errorf(t, "expected ')'")
451 | 	}
452 | 	return &pseudoClassSelector{pos: pos, function: t.s, args: args}, nil
453 | }
454 | 
455 | // https://drafts.csswg.org/css-syntax-3/#typedef-any-value
456 | func (p *parser) any(until tokenType) ([]token, error) {
457 | 	var (
458 | 		tokens      []token
459 | 		wantClosing []tokenType
460 | 	)
461 | 	for {
462 | 		if len(wantClosing) == 0 {
463 | 			t, err := p.peek()
464 | 			if err != nil {
465 | 				return nil, err
466 | 			}
467 | 			if t.typ == until {
468 | 				return tokens, nil
469 | 			}
470 | 		}
471 | 
472 | 		t, err := p.next()
473 | 		if err != nil {
474 | 			return nil, err
475 | 		}
476 | 		switch t.typ {
477 | 		case tokenEOF:
478 | 			return nil, p.errorf(t, "unexpected eof attempting to match '%s'", until)
479 | 		case tokenBracketOpen:
480 | 			wantClosing = append(wantClosing, tokenBracketClose)
481 | 		case tokenCurlyOpen:
482 | 			wantClosing = append(wantClosing, tokenCurlyClose)
483 | 		case tokenParenOpen:
484 | 			wantClosing = append(wantClosing, tokenParenClose)
485 | 		case tokenBracketClose, tokenCurlyClose, tokenParenClose:
486 | 			if len(wantClosing) == 0 || wantClosing[len(wantClosing)-1] != t.typ {
487 | 				return nil, p.errorf(t, "unmatched '%s'", t.s)
488 | 			}
489 | 			wantClosing = wantClosing[:len(wantClosing)-1]
490 | 		}
491 | 		tokens = append(tokens, t)
492 | 	}
493 | }
494 | 
495 | func (p *parser) skipWhitespace() bool {
496 | 	seen := false
497 | 	for {
498 | 		t, err := p.peek()
499 | 		if err != nil || t.typ != tokenWhitespace {
500 | 			return seen
501 | 		}
502 | 		seen = true
503 | 		p.next()
504 | 	}
505 | }
506 | 
507 | func (p *parser) expectWhitespaceOrEOF() error {
508 | 	p.skipWhitespace()
509 | 	t, err := p.next()
510 | 	if err != nil {
511 | 		return err
512 | 	}
513 | 	if t.typ != tokenEOF {
514 | 		return p.errorf(t, "expected no more tokens")
515 | 	}
516 | 	return nil
517 | }
518 | 
519 | // <attribute-selector> = '[' <wq-name> ']' |
520 | //                        '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'
521 | // <attr-matcher> = [ '~' | '|' | '^' | '$' | '*' ]? '='
522 | // <attr-modifier> = i
523 | // <wq-name> = <ns-prefix>? <ident-token>
524 | // <ns-prefix> = [ <ident-token> | '*' ]? '|'
525 | //
526 | // https://www.w3.org/TR/selectors-4/#typedef-attribute-selector
527 | type attributeSelector struct {
528 | 	pos      int
529 | 	wqName   *wqName
530 | 	matcher  string
531 | 	val      string
532 | 	modifier bool
533 | }
534 | 
535 | func (p *parser) attributeSelector() (*attributeSelector, error) {
536 | 	// '['
537 | 	t, err := p.next()
538 | 	if err != nil {
539 | 		return nil, err
540 | 	}
541 | 	if t.typ != tokenBracketOpen {
542 | 		return nil, p.errorf(t, "expected '['")
543 | 	}
544 | 	at := &attributeSelector{pos: t.pos}
545 | 	p.skipWhitespace()
546 | 
547 | 	// <wq-name>
548 | 	name, err := p.wqName()
549 | 	if err != nil {
550 | 		return nil, err
551 | 	}
552 | 	at.wqName = name
553 | 	p.skipWhitespace()
554 | 
555 | 	t, err = p.next()
556 | 	if err != nil {
557 | 		return nil, err
558 | 	}
559 | 	if t.typ == tokenBracketClose {
560 | 		// Found ']', we're done.
561 | 		return at, nil
562 | 	}
563 | 
564 | 	// <attr-matcher> = [ '~' | '|' | '^' | '$' | '*' ]? '='
565 | 	if t.typ != tokenDelim {
566 | 		return nil, p.errorf(t, "expected '~', '|', '^', '$', '*' or '='")
567 | 	}
568 | 	switch t.s {
569 | 	case "~", "|", "^", "$", "*", "=":
570 | 	default:
571 | 		return nil, p.errorf(t, "expected '~', '|', '^', '$', '*' or '='")
572 | 	}
573 | 	at.matcher = "="
574 | 	if t.s != "=" {
575 | 		// https://www.w3.org/TR/selectors-4/#white-space
576 | 		//
577 | 		// Whitespace is forbidden between elements of the <attr-matcher>.
578 | 
579 | 		at.matcher = t.s + "="
580 | 		t, err = p.next()
581 | 		if err != nil {
582 | 			return nil, err
583 | 		}
584 | 		if !t.isDelim("=") {
585 | 			return nil, p.errorf(t, "expected '='")
586 | 		}
587 | 	}
588 | 	p.skipWhitespace()
589 | 
590 | 	// [ <string-token> | <ident-token> ]
591 | 	strOrIdent, err := p.next()
592 | 	if err != nil {
593 | 		return nil, err
594 | 	}
595 | 	if !(strOrIdent.typ == tokenString || strOrIdent.typ == tokenIdent) {
596 | 		return nil, p.errorf(strOrIdent, "expected identifier or string")
597 | 	}
598 | 	at.val = strOrIdent.s
599 | 
600 | 	p.skipWhitespace()
601 | 
602 | 	// <attr-modifier>?
603 | 	t, err = p.next()
604 | 	if err != nil {
605 | 		return nil, err
606 | 	}
607 | 	if t.s == "i" {
608 | 		at.modifier = true
609 | 		p.skipWhitespace()
610 | 
611 | 		t, err = p.next()
612 | 		if err != nil {
613 | 			return nil, err
614 | 		}
615 | 	}
616 | 	if t.typ != tokenBracketClose {
617 | 		return nil, p.errorf(t, "expected ']'")
618 | 	}
619 | 	return at, nil
620 | }
621 | 
622 | type wqName struct {
623 | 	hasPrefix bool
624 | 	prefix    string
625 | 	value     string
626 | }
627 | 
628 | // <wq-name> = <ns-prefix>? <ident-token>
629 | // <ns-prefix> = [ <ident-token> | '*' ]? '|'
630 | //
631 | // https://www.w3.org/TR/selectors-4/#typedef-wq-name
632 | func (p *parser) wqName() (*wqName, error) {
633 | 	return p.parseName(false)
634 | }
635 | 
636 | // parseName handles either <wq-name> or <type-selector>, which are almost
637 | // identical. However <type-selector> allows '*' as the final element.
638 | //
639 | // <wq-name>       = <ns-prefix>? <ident-token>
640 | // <type-selector> = <ns-prefix>? [ <ident-token> | '*' ]
641 | //
642 | // https://www.w3.org/TR/selectors-4/#typedef-wq-name
643 | // https://www.w3.org/TR/selectors-4/#typedef-type-selector
644 | func (p *parser) parseName(allowStar bool) (*wqName, error) {
645 | 	t, err := p.next()
646 | 	if err != nil {
647 | 		return nil, err
648 | 	}
649 | 	if t.isDelim("|") {
650 | 		t, err := p.next()
651 | 		if err != nil {
652 | 			return nil, err
653 | 		}
654 | 		if t.typ != tokenIdent {
655 | 			return nil, p.errorf(t, "expected identifier")
656 | 		}
657 | 		return &wqName{true, "", t.s}, nil
658 | 	}
659 | 	if t.isDelim("*") {
660 | 		delim, err := p.peek()
661 | 		if err != nil {
662 | 			return nil, err
663 | 		}
664 | 		if !delim.isDelim("|") {
665 | 			if allowStar {
666 | 				return &wqName{false, "", "*"}, nil
667 | 			}
668 | 			return nil, p.errorf(delim, "expected '|'")
669 | 		}
670 | 
671 | 		// Consume the "|" delim.
672 | 		p.next()
673 | 
674 | 		ident, err := p.next()
675 | 		if err != nil {
676 | 			return nil, err
677 | 		}
678 | 		if !(ident.typ == tokenIdent || (allowStar && ident.isDelim("*"))) {
679 | 			return nil, p.errorf(ident, "expected identifier")
680 | 		}
681 | 		return &wqName{true, t.s, ident.s}, nil
682 | 	}
683 | 	if t.typ != tokenIdent {
684 | 		return nil, p.errorf(t, "expected identifier")
685 | 	}
686 | 
687 | 	// See if the stream contains '|' <ident-token>.
688 | 	delim, err := p.peek()
689 | 	if err != nil {
690 | 		return nil, err
691 | 	}
692 | 	if !delim.isDelim("|") {
693 | 		return &wqName{false, "", t.s}, nil
694 | 	}
695 | 	ident, err := p.peekN(1)
696 | 	if err != nil {
697 | 		return nil, err
698 | 	}
699 | 	if !(ident.typ == tokenIdent || (allowStar && ident.isDelim("*"))) {
700 | 		return &wqName{false, "", t.s}, nil
701 | 	}
702 | 	// Consume peeked tokens.
703 | 	p.next()
704 | 	p.next()
705 | 	return &wqName{true, t.s, ident.s}, nil
706 | }
707 | 
708 | // https://drafts.csswg.org/css-syntax-3/#typedef-n-dimension
709 | func isNDimension(t token) bool {
710 | 	return t.typ == tokenDimension && t.flag == tokenFlagInteger && t.dim == "n"
711 | }
712 | 
713 | // https://drafts.csswg.org/css-syntax-3/#typedef-ndash-dimension
714 | func isNDashDimension(t token) bool {
715 | 	return t.typ == tokenDimension && t.dim == "n-"
716 | }
717 | 
718 | func isPrefixWithDigits(s, prefix string) bool {
719 | 	if !strings.HasPrefix(s, prefix) {
720 | 		return false
721 | 	}
722 | 	if len(s) == len(prefix) {
723 | 		return false
724 | 	}
725 | 	for _, c := range s[len(prefix):] {
726 | 		if !isDigit(c) {
727 | 			return false
728 | 		}
729 | 	}
730 | 	return true
731 | }
732 | 
733 | // isNDashDigitDimension looks for patterns like "n-13213".
734 | //
735 | // https://drafts.csswg.org/css-syntax-3/#typedef-ndashdigit-dimension
736 | func isNDashDigitDimension(t token) bool {
737 | 	return t.typ == tokenDimension && isPrefixWithDigits(t.dim, "n-")
738 | }
739 | 
740 | // https://drafts.csswg.org/css-syntax-3/#typedef-ndashdigit-ident
741 | func isNDashDigitIdent(t token) bool {
742 | 	return t.typ == tokenIdent && isPrefixWithDigits(t.s, "n-")
743 | }
744 | 
745 | // https://drafts.csswg.org/css-syntax-3/#typedef-dashndashdigit-ident
746 | func isDashNDashDigitIdent(t token) bool {
747 | 	return t.typ == tokenIdent && isPrefixWithDigits(t.s, "-n-")
748 | }
749 | 
750 | // https://drafts.csswg.org/css-syntax-3/#typedef-integer
751 | func isInteger(t token) bool {
752 | 	return t.typ == tokenNumber && t.flag == tokenFlagInteger
753 | }
754 | 
755 | // https://drafts.csswg.org/css-syntax-3/#typedef-signed-integer
756 | func isSignedInteger(t token) bool {
757 | 	return isInteger(t) && (strings.HasPrefix(t.s, "+") || strings.HasPrefix(t.s, "-"))
758 | }
759 | 
760 | // https://drafts.csswg.org/css-syntax-3/#typedef-signless-integer
761 | func isSignlessInteger(t token) bool {
762 | 	return isInteger(t) && strings.IndexFunc(t.s, isDigit) == 0
763 | }
764 | 
765 | func parseInt(s string) (int64, error) {
766 | 	return strconv.ParseInt(s, 10, 64)
767 | }
768 | 
769 | // b parses the common pattern of <signed-integer> | ['+' | '-'] <signless-integer>
770 | func (p *parser) b() (int64, error) {
771 | 	p.skipWhitespace()
772 | 	t, err := p.next()
773 | 	if err != nil {
774 | 		return 0, err
775 | 	}
776 | 	if t.typ == tokenEOF {
777 | 		return 0, nil
778 | 	}
779 | 
780 | 	if isSignedInteger(t) {
781 | 		n, err := parseInt(t.s)
782 | 		if err != nil {
783 | 			return 0, p.errorf(t, "parsing value as integer: %v", err)
784 | 		}
785 | 		return n, nil
786 | 	}
787 | 	if !(t.isDelim("+") || t.isDelim("-")) {
788 | 		return 0, p.errorf(t, "expected one of the following: <signed-intger>, '+', '-'")
789 | 	}
790 | 	isNeg := t.isDelim("-")
791 | 
792 | 	p.skipWhitespace()
793 | 	t, err = p.next()
794 | 	if err != nil {
795 | 		return 0, err
796 | 	}
797 | 
798 | 	if !isSignlessInteger(t) {
799 | 		return 0, p.errorf(t, "expected <signless-integer>")
800 | 	}
801 | 	n, err := parseInt(t.s)
802 | 	if err != nil {
803 | 		return 0, p.errorf(t, "parsing value as integer: %v", err)
804 | 	}
805 | 	if isNeg {
806 | 		return 0 - n, nil
807 | 	}
808 | 	return n, nil
809 | }
810 | 
811 | // https://drafts.csswg.org/css-syntax-3/#the-anb-type
812 | func (p *parser) aNPlusB() (*nth, error) {
813 | 	p.skipWhitespace()
814 | 	t, err := p.next()
815 | 	if err != nil {
816 | 		return nil, err
817 | 	}
818 | 	if t.isIdent("even") {
819 | 		return &nth{a: 2}, nil
820 | 	}
821 | 	if t.isIdent("odd") {
822 | 		return &nth{a: 2, b: 1}, nil
823 | 	}
824 | 	if isInteger(t) {
825 | 		b, err := parseInt(t.s)
826 | 		if err != nil {
827 | 			return nil, p.errorf(t, "parsing value as integer: %v", err)
828 | 		}
829 | 		return &nth{b: b}, nil
830 | 	}
831 | 
832 | 	if isNDimension(t) {
833 | 		a, err := parseInt(t.s)
834 | 		if err != nil {
835 | 			return nil, p.errorf(t, "parsing value as integer: %v", err)
836 | 		}
837 | 		b, err := p.b()
838 | 		if err != nil {
839 | 			return nil, err
840 | 		}
841 | 		return &nth{a: a, b: b}, nil
842 | 	}
843 | 
844 | 	if isNDashDigitDimension(t) {
845 | 		// Token is of form "4n-3" where "4" is the string and "n-3" is the
846 | 		// dimension.
847 | 		a, err := parseInt(t.s)
848 | 		if err != nil {
849 | 			return nil, p.errorf(t, "parsing value as integer: %v", err)
850 | 		}
851 | 		b, err := parseInt(strings.TrimPrefix(t.dim, "n"))
852 | 		if err != nil {
853 | 			return nil, p.errorf(t, "parsing dimension as integer: %v", err)
854 | 		}
855 | 		return &nth{a: a, b: b}, nil
856 | 	}
857 | 
858 | 	if isDashNDashDigitIdent(t) {
859 | 		// Token is of form "-n-3".
860 | 		b, err := parseInt(strings.TrimPrefix(t.s, "-n"))
861 | 		if err != nil {
862 | 			return nil, p.errorf(t, "parsing b as integer: %v", err)
863 | 		}
864 | 		return &nth{a: -1, b: b}, nil
865 | 	}
866 | 
867 | 	if isNDashDimension(t) {
868 | 		// String is of form "4n- 3".
869 | 		a, err := parseInt(t.s)
870 | 		if err != nil {
871 | 			return nil, p.errorf(t, "parsing value as integer: %v", err)
872 | 		}
873 | 		p.skipWhitespace()
874 | 		t, err := p.next()
875 | 		if err != nil {
876 | 			return nil, err
877 | 		}
878 | 		if !isSignlessInteger(t) {
879 | 			return nil, p.errorf(t, "expected unsigned integer")
880 | 		}
881 | 		n, err := parseInt(t.s)
882 | 		if err != nil {
883 | 			return nil, p.errorf(t, "parsing value as integer: %v", err)
884 | 		}
885 | 		return &nth{a: a, b: 0 - n}, nil
886 | 	}
887 | 
888 | 	if t.isIdent("-n-") {
889 | 		// String is of form "-n- 3".
890 | 		p.skipWhitespace()
891 | 		t, err := p.next()
892 | 		if err != nil {
893 | 			return nil, err
894 | 		}
895 | 		if !isSignlessInteger(t) {
896 | 			return nil, p.errorf(t, "expected unsigned integer")
897 | 		}
898 | 		n, err := parseInt(t.s)
899 | 		if err != nil {
900 | 			return nil, p.errorf(t, "parsing value as integer: %v", err)
901 | 		}
902 | 		return &nth{a: -1, b: 0 - n}, nil
903 | 	}
904 | 
905 | 	if t.isIdent("-n") {
906 | 		b, err := p.b()
907 | 		if err != nil {
908 | 			return nil, err
909 | 		}
910 | 		return &nth{a: -1, b: b}, nil
911 | 	}
912 | 
913 | 	if t.isDelim("+") {
914 | 		p.skipWhitespace()
915 | 		tok, err := p.next()
916 | 		if err != nil {
917 | 			return nil, err
918 | 		}
919 | 		t = tok
920 | 	}
921 | 
922 | 	if t.isIdent("n") {
923 | 		b, err := p.b()
924 | 		if err != nil {
925 | 			return nil, err
926 | 		}
927 | 		return &nth{a: 1, b: b}, nil
928 | 	}
929 | 
930 | 	if t.isIdent("n-") {
931 | 		p.skipWhitespace()
932 | 		tok, err := p.next()
933 | 		if err != nil {
934 | 			return nil, err
935 | 		}
936 | 		t = tok
937 | 		if !isSignlessInteger(t) {
938 | 			return nil, p.errorf(t, "expected unsigned integer")
939 | 		}
940 | 		n, err := parseInt(t.s)
941 | 		if err != nil {
942 | 			return nil, p.errorf(t, "parsing value as integer: %v", err)
943 | 		}
944 | 		return &nth{a: 1, b: 0 - n}, nil
945 | 	}
946 | 	return nil, p.errorf(t, "expected 'even', 'odd', or integer type")
947 | }
948 | 


--------------------------------------------------------------------------------
/parse_test.go:
--------------------------------------------------------------------------------
  1 | package css
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"reflect"
  6 | 	"testing"
  7 | 
  8 | 	"github.com/google/go-cmp/cmp"
  9 | )
 10 | 
 11 | func cmpDiff(x, y interface{}) string {
 12 | 	return cmp.Diff(x, y, cmp.AllowUnexported(
 13 | 		attributeSelector{},
 14 | 		complexSelector{},
 15 | 		compoundSelector{},
 16 | 		pseudoClassSelector{},
 17 | 		pseudoSelector{},
 18 | 		subclassSelector{},
 19 | 		token{},
 20 | 		typeSelector{},
 21 | 		wqName{},
 22 | 	))
 23 | }
 24 | 
 25 | func TestParse(t *testing.T) {
 26 | 	tests := []struct {
 27 | 		s    string
 28 | 		want []complexSelector
 29 | 	}{
 30 | 		{"foo", []complexSelector{
 31 | 			{
 32 | 				sel: compoundSelector{
 33 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
 34 | 				},
 35 | 			},
 36 | 		}},
 37 | 		{"foo bar", []complexSelector{
 38 | 			{
 39 | 				sel: compoundSelector{
 40 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
 41 | 				},
 42 | 				combinator: "",
 43 | 				next: &complexSelector{
 44 | 					pos: 4,
 45 | 					sel: compoundSelector{
 46 | 						pos:          4,
 47 | 						typeSelector: &typeSelector{pos: 4, value: "bar"},
 48 | 					},
 49 | 				},
 50 | 			},
 51 | 		}},
 52 | 		{"foo bar spam", []complexSelector{
 53 | 			{
 54 | 				sel: compoundSelector{
 55 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
 56 | 				},
 57 | 				combinator: "",
 58 | 				next: &complexSelector{
 59 | 					pos: 4,
 60 | 					sel: compoundSelector{
 61 | 						pos:          4,
 62 | 						typeSelector: &typeSelector{pos: 4, value: "bar"},
 63 | 					},
 64 | 					combinator: "",
 65 | 					next: &complexSelector{
 66 | 						pos: 8,
 67 | 						sel: compoundSelector{
 68 | 							pos:          8,
 69 | 							typeSelector: &typeSelector{pos: 8, value: "spam"},
 70 | 						},
 71 | 					},
 72 | 				},
 73 | 			},
 74 | 		}},
 75 | 		{"foo bar > spam", []complexSelector{
 76 | 			{
 77 | 				sel: compoundSelector{
 78 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
 79 | 				},
 80 | 				combinator: "",
 81 | 				next: &complexSelector{
 82 | 					pos: 4,
 83 | 					sel: compoundSelector{
 84 | 						pos:          4,
 85 | 						typeSelector: &typeSelector{pos: 4, value: "bar"},
 86 | 					},
 87 | 					combinator: ">",
 88 | 					next: &complexSelector{
 89 | 						pos: 10,
 90 | 						sel: compoundSelector{
 91 | 							pos:          10,
 92 | 							typeSelector: &typeSelector{pos: 10, value: "spam"},
 93 | 						},
 94 | 					},
 95 | 				},
 96 | 			},
 97 | 		}},
 98 | 		{"foo > bar", []complexSelector{
 99 | 			{
100 | 				sel: compoundSelector{
101 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
102 | 				},
103 | 				combinator: ">",
104 | 				next: &complexSelector{
105 | 					pos: 6,
106 | 					sel: compoundSelector{
107 | 						pos:          6,
108 | 						typeSelector: &typeSelector{pos: 6, value: "bar"},
109 | 					},
110 | 				},
111 | 			},
112 | 		}},
113 | 		{"foo, bar", []complexSelector{
114 | 			{
115 | 				sel: compoundSelector{
116 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
117 | 				},
118 | 			},
119 | 			{
120 | 				pos: 5,
121 | 				sel: compoundSelector{
122 | 					pos:          5,
123 | 					typeSelector: &typeSelector{pos: 5, value: "bar"},
124 | 				},
125 | 			},
126 | 		}},
127 | 		{"foo, .bar", []complexSelector{
128 | 
129 | 			{
130 | 				sel: compoundSelector{
131 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
132 | 				},
133 | 			},
134 | 			{
135 | 				pos: 5,
136 | 				sel: compoundSelector{
137 | 					pos:        5,
138 | 					subClasses: []subclassSelector{{pos: 5, classSelector: "bar"}},
139 | 				},
140 | 			},
141 | 		}},
142 | 		{".foo", []complexSelector{
143 | 			{
144 | 				sel: compoundSelector{
145 | 					subClasses: []subclassSelector{
146 | 						{classSelector: "foo"},
147 | 					},
148 | 				},
149 | 			},
150 | 		}},
151 | 		{"#foo", []complexSelector{
152 | 			{
153 | 				sel: compoundSelector{
154 | 					subClasses: []subclassSelector{
155 | 						{idSelector: "foo"},
156 | 					},
157 | 				},
158 | 			},
159 | 		}},
160 | 		{"foo > bar", []complexSelector{
161 | 			{
162 | 				sel: compoundSelector{
163 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
164 | 				},
165 | 				combinator: ">",
166 | 				next: &complexSelector{
167 | 					pos: 6,
168 | 					sel: compoundSelector{
169 | 						pos:          6,
170 | 						typeSelector: &typeSelector{pos: 6, value: "bar"},
171 | 					},
172 | 				},
173 | 			},
174 | 		}},
175 | 		{"foo > bar||spam", []complexSelector{
176 | 			{
177 | 				sel: compoundSelector{
178 | 					typeSelector: &typeSelector{value: "foo"},
179 | 				},
180 | 				combinator: ">",
181 | 				next: &complexSelector{
182 | 					pos: 6,
183 | 					sel: compoundSelector{
184 | 						pos:          6,
185 | 						typeSelector: &typeSelector{pos: 6, value: "bar"},
186 | 					},
187 | 					combinator: "||",
188 | 					next: &complexSelector{
189 | 						pos: 11,
190 | 						sel: compoundSelector{
191 | 							pos:          11,
192 | 							typeSelector: &typeSelector{pos: 11, value: "spam"},
193 | 						},
194 | 					},
195 | 				},
196 | 			},
197 | 		}},
198 | 		{"foo::bar", []complexSelector{
199 | 			{
200 | 				sel: compoundSelector{
201 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
202 | 					pseudoSelectors: []pseudoSelector{
203 | 						{
204 | 							element: pseudoClassSelector{pos: 4, ident: "bar"},
205 | 						},
206 | 					},
207 | 				},
208 | 			},
209 | 		}},
210 | 		{"foo::bar :spam :biz", []complexSelector{
211 | 			{
212 | 				sel: compoundSelector{
213 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
214 | 					pseudoSelectors: []pseudoSelector{
215 | 						{
216 | 							element: pseudoClassSelector{pos: 4, ident: "bar"},
217 | 							classes: []pseudoClassSelector{{pos: 9, ident: "spam"}, {pos: 15, ident: "biz"}},
218 | 						},
219 | 					},
220 | 				},
221 | 			},
222 | 		}},
223 | 		{"foo::myfunc(a, b, (c))", []complexSelector{
224 | 			{
225 | 				sel: compoundSelector{
226 | 					typeSelector: &typeSelector{pos: 0, value: "foo"},
227 | 					pseudoSelectors: []pseudoSelector{
228 | 						{
229 | 							element: pseudoClassSelector{
230 | 								pos:      4,
231 | 								function: "myfunc(",
232 | 								args: []token{
233 | 									{tokenIdent, "a", "a", 12, 0, ""},
234 | 									{tokenComma, ",", ",", 13, 0, ""},
235 | 									{tokenWhitespace, " ", " ", 14, 0, ""},
236 | 									{tokenIdent, "b", "b", 15, 0, ""},
237 | 									{tokenComma, ",", ",", 16, 0, ""},
238 | 									{tokenWhitespace, " ", " ", 17, 0, ""},
239 | 									{tokenParenOpen, "(", "(", 18, 0, ""},
240 | 									{tokenIdent, "c", "c", 19, 0, ""},
241 | 									{tokenParenClose, ")", ")", 20, 0, ""},
242 | 								},
243 | 							},
244 | 						},
245 | 					},
246 | 				},
247 | 			},
248 | 		}},
249 | 		{":nth-child(4n+3)", []complexSelector{
250 | 			{
251 | 				sel: compoundSelector{
252 | 
253 | 					subClasses: []subclassSelector{
254 | 						{
255 | 							pseudoClassSelector: &pseudoClassSelector{
256 | 								function: "nth-child(",
257 | 								args: []token{
258 | 									{tokenDimension, "4n", "4", 11, tokenFlagInteger, "n"},
259 | 									{tokenNumber, "+3", "+3", 13, tokenFlagInteger, ""},
260 | 								},
261 | 							},
262 | 						},
263 | 					},
264 | 				},
265 | 			},
266 | 		}},
267 | 		{":nth-child(4n + 3)", []complexSelector{
268 | 			{
269 | 				sel: compoundSelector{
270 | 
271 | 					subClasses: []subclassSelector{
272 | 						{
273 | 							pseudoClassSelector: &pseudoClassSelector{
274 | 								function: "nth-child(",
275 | 								args: []token{
276 | 									{tokenDimension, "4n", "4", 11, tokenFlagInteger, "n"},
277 | 									{tokenWhitespace, " ", " ", 13, 0, ""},
278 | 									{tokenDelim, "+", "+", 14, 0, ""},
279 | 									{tokenWhitespace, " ", " ", 15, 0, ""},
280 | 									{tokenNumber, "3", "3", 16, tokenFlagInteger, ""},
281 | 								},
282 | 							},
283 | 						},
284 | 					},
285 | 				},
286 | 			},
287 | 		}},
288 | 	}
289 | 	for _, test := range tests {
290 | 		p := newParser(test.s)
291 | 		got, err := p.parse()
292 | 		if err != nil {
293 | 			t.Errorf("parsing %q: %v", test.s, err)
294 | 			continue
295 | 		}
296 | 		if diff := cmpDiff(test.want, got); diff != "" {
297 | 			t.Errorf("parsing %q returned diff (-want +got) %s", test.s, diff)
298 | 		}
299 | 	}
300 | }
301 | 
302 | type testMethod struct {
303 | 	name string
304 | 	fn   func(p *parser) (interface{}, error)
305 | }
306 | 
307 | func TestSubParser(t *testing.T) {
308 | 	parsePseudoClass := testMethod{
309 | 		name: "pseudoClassSelector()",
310 | 		fn: func(p *parser) (interface{}, error) {
311 | 			return p.pseudoClassSelector()
312 | 		},
313 | 	}
314 | 	parseWQName := testMethod{
315 | 		name: "wqName()",
316 | 		fn: func(p *parser) (interface{}, error) {
317 | 			return p.wqName()
318 | 		},
319 | 	}
320 | 	parseAttrSel := testMethod{
321 | 		name: "attributeSelector()",
322 | 		fn: func(p *parser) (interface{}, error) {
323 | 			return p.attributeSelector()
324 | 		},
325 | 	}
326 | 	parseSubclassSel := testMethod{
327 | 		name: "subclassSelector()",
328 | 		fn: func(p *parser) (interface{}, error) {
329 | 			ss, ok, err := p.subclassSelector()
330 | 			if err != nil {
331 | 				return nil, err
332 | 			}
333 | 			if !ok {
334 | 				return false, nil
335 | 			}
336 | 			return ss, nil
337 | 		},
338 | 	}
339 | 	parseTypeSel := testMethod{
340 | 		name: "typeSelector()",
341 | 		fn: func(p *parser) (interface{}, error) {
342 | 			s, ok, err := p.typeSelector()
343 | 			if err != nil {
344 | 				return nil, err
345 | 			}
346 | 			if !ok {
347 | 				return false, nil
348 | 			}
349 | 			return s, nil
350 | 		},
351 | 	}
352 | 
353 | 	tests := []struct {
354 | 		method     testMethod
355 | 		s          string
356 | 		want       interface{}
357 | 		wantErrPos int
358 | 	}{
359 | 		{parsePseudoClass, ":foo", &pseudoClassSelector{0, "foo", "", nil}, -1},
360 | 		{parsePseudoClass, ": foo", nil, 1}, // https://www.w3.org/TR/selectors-4/#white-space
361 | 		{parsePseudoClass, ":foo()", &pseudoClassSelector{0, "", "foo(", nil}, -1},
362 | 		{parsePseudoClass, ":foo(a)", &pseudoClassSelector{0, "", "foo(", []token{
363 | 			token{tokenIdent, "a", "a", 5, 0, ""},
364 | 		}}, -1},
365 | 		{parsePseudoClass, ":foo(a, b)", &pseudoClassSelector{0, "", "foo(", []token{
366 | 			token{tokenIdent, "a", "a", 5, 0, ""},
367 | 			token{tokenComma, ",", ",", 6, 0, ""},
368 | 			token{tokenWhitespace, " ", " ", 7, 0, ""},
369 | 			token{tokenIdent, "b", "b", 8, 0, ""},
370 | 		}}, -1},
371 | 		{parseWQName, "foo", &wqName{false, "", "foo"}, -1},
372 | 		{parseWQName, "foo|bar", &wqName{true, "foo", "bar"}, -1},
373 | 		{parseWQName, "|bar", &wqName{true, "", "bar"}, -1},
374 | 		{parseWQName, "*|bar", &wqName{true, "*", "bar"}, -1},
375 | 		{parseWQName, "foo|*", &wqName{false, "", "foo"}, -1},
376 | 		{parseWQName, "*|*", nil, 2},
377 | 		{parseWQName, "*foo", nil, 1},
378 | 		{parseWQName, "foo |bar", &wqName{false, "", "foo"}, -1}, // Whitespace ignored
379 | 		{parseWQName, "foo| bar", &wqName{false, "", "foo"}, -1}, // Whitespace ignored
380 | 		{parseTypeSel, "foo", &typeSelector{0, false, "", "foo"}, -1},
381 | 		{parseTypeSel, "foo|bar", &typeSelector{0, true, "foo", "bar"}, -1},
382 | 		{parseTypeSel, "|bar", &typeSelector{0, true, "", "bar"}, -1},
383 | 		{parseTypeSel, "*|bar", &typeSelector{0, true, "*", "bar"}, -1},
384 | 		{parseTypeSel, "foo|*", &typeSelector{0, true, "foo", "*"}, -1},
385 | 		{parseTypeSel, "*|*", &typeSelector{0, true, "*", "*"}, -1},
386 | 		{parseTypeSel, "*foo", &typeSelector{0, false, "", "*"}, -1},
387 | 		{parseTypeSel, "foo |bar", &typeSelector{0, false, "", "foo"}, -1}, // Whitespace ignored
388 | 		{parseTypeSel, "foo| bar", &typeSelector{0, false, "", "foo"}, -1}, // Whitespace ignored
389 | 		{parseAttrSel, "[foo]", &attributeSelector{
390 | 			0, &wqName{false, "", "foo"}, "", "", false,
391 | 		}, -1},
392 | 		{parseAttrSel, "[ foo = \"bar\" ]", &attributeSelector{
393 | 			0, &wqName{false, "", "foo"}, "=", "bar", false,
394 | 		}, -1},
395 | 		{parseAttrSel, "[foo=\"bar\"]", &attributeSelector{
396 | 			0, &wqName{false, "", "foo"}, "=", "bar", false,
397 | 		}, -1},
398 | 		{parseAttrSel, "[*|foo=\"bar\"]", &attributeSelector{
399 | 			0, &wqName{true, "*", "foo"}, "=", "bar", false,
400 | 		}, -1},
401 | 		{parseAttrSel, "[*|foo=bar]", &attributeSelector{
402 | 			0, &wqName{true, "*", "foo"}, "=", "bar", false,
403 | 		}, -1},
404 | 		{parseAttrSel, "[*|foo=bar i]", &attributeSelector{
405 | 			0, &wqName{true, "*", "foo"}, "=", "bar", true,
406 | 		}, -1},
407 | 		{parseAttrSel, "[foo^=bar]", &attributeSelector{
408 | 			0, &wqName{false, "", "foo"}, "^=", "bar", false,
409 | 		}, -1},
410 | 		{parseSubclassSel, "", false, -1},
411 | 		{parseSubclassSel, "#foo", &subclassSelector{idSelector: "foo"}, -1},
412 | 		{parseSubclassSel, ".foo", &subclassSelector{classSelector: "foo"}, -1},
413 | 		{parseSubclassSel, ".foo()", nil, 1},
414 | 		{parseSubclassSel, "[foo=bar]", &subclassSelector{
415 | 			attributeSelector: &attributeSelector{0, &wqName{false, "", "foo"}, "=", "bar", false},
416 | 		}, -1},
417 | 		{parseSubclassSel, ":foo", &subclassSelector{
418 | 			pseudoClassSelector: &pseudoClassSelector{0, "foo", "", nil},
419 | 		}, -1},
420 | 		{parseSubclassSel, "::foo", false, -1},
421 | 		{parseWQName, "foo", &wqName{false, "", "foo"}, -1},
422 | 		{parseWQName, "foo|bar", &wqName{true, "foo", "bar"}, -1},
423 | 		{parseWQName, "|bar", &wqName{true, "", "bar"}, -1},
424 | 		{parseWQName, "*|bar", &wqName{true, "*", "bar"}, -1},
425 | 		{parseWQName, "foo|*", &wqName{false, "", "foo"}, -1},
426 | 		{parseWQName, "*|*", nil, 2},
427 | 		{parseWQName, "*foo", nil, 1},
428 | 		{parseWQName, "foo |bar", &wqName{false, "", "foo"}, -1}, // Whitespace ignored
429 | 		{parseWQName, "foo| bar", &wqName{false, "", "foo"}, -1}, // Whitespace ignored
430 | 	}
431 | 	for _, test := range tests {
432 | 		t.Run(test.method.name+test.s, func(t *testing.T) {
433 | 			p := newParser(test.s)
434 | 			got, err := test.method.fn(p)
435 | 			if err != nil {
436 | 				if test.wantErrPos < 0 {
437 | 					t.Fatalf("parsing failed %v", err)
438 | 				}
439 | 				var perr *parseErr
440 | 				if !errors.As(err, &perr) {
441 | 					t.Fatalf("got err %v, want *parseErr", err)
442 | 				}
443 | 				if perr.t.pos != test.wantErrPos {
444 | 					t.Fatalf("got error at pos %d, want %d", perr.t.pos, test.wantErrPos)
445 | 				}
446 | 				return
447 | 			}
448 | 
449 | 			if test.wantErrPos >= 0 {
450 | 				t.Fatalf("expected error at position %d", test.wantErrPos)
451 | 			}
452 | 			if !reflect.DeepEqual(got, test.want) {
453 | 				t.Errorf("got %v, want %v", got, test.want)
454 | 			}
455 | 		})
456 | 	}
457 | }
458 | 
459 | func TestANPlusB(t *testing.T) {
460 | 	tests := []struct {
461 | 		s       string
462 | 		a       int64
463 | 		b       int64
464 | 		wantErr bool
465 | 	}{
466 | 		{"even", 2, 0, false},
467 | 		{"odd", 2, 1, false},
468 | 		{"even odd", 0, 0, true},
469 | 		{"4n", 4, 0, false},
470 | 		{"+4n", 4, 0, false},
471 | 		{"-4n", -4, 0, false},
472 | 		{"+ 4n", 0, 0, true},
473 | 		{"4n +3", 4, 3, false},
474 | 		{"4n -3", 4, -3, false},
475 | 		{"4n + 3", 4, 3, false},
476 | 		{"4n - 3", 4, -3, false},
477 | 		{"4n+3", 4, 3, false},
478 | 		{"4n-3", 4, -3, false},
479 | 		{"-n-3", -1, -3, false},
480 | 		{"-n -3", -1, -3, false},
481 | 		{"-n - 3", -1, -3, false},
482 | 		{"-n + 3", -1, 3, false},
483 | 		{"-n", -1, 0, false},
484 | 		{"4n- 3", 4, -3, false},
485 | 		{"-n- 3", -1, -3, false},
486 | 		{"+n", 1, 0, false},
487 | 		{"+n- 3", 1, -3, false},
488 | 		{"+n- -3", 0, 0, true},
489 | 	}
490 | 
491 | 	for _, test := range tests {
492 | 		p := newParser(test.s)
493 | 		got, err := p.aNPlusB()
494 | 		if err != nil {
495 | 			if test.wantErr {
496 | 				continue
497 | 			}
498 | 			t.Errorf("Failed to parse string %s: %v", test.s, err)
499 | 			continue
500 | 		}
501 | 		tok, err := p.peek()
502 | 		if err != nil {
503 | 			t.Errorf("Failed to peek next token for string %s: %v", test.s, err)
504 | 			continue
505 | 		}
506 | 		if err := p.expectWhitespaceOrEOF(); err != nil {
507 | 			if test.wantErr {
508 | 				continue
509 | 			}
510 | 			t.Errorf("Parsing string, expected eof or whitespace at token %s for string %s", tok, test.s)
511 | 			continue
512 | 		}
513 | 		if test.wantErr {
514 | 			t.Errorf("Expected error parsing %s: %v", test.s, err)
515 | 			continue
516 | 		}
517 | 		if test.a != got.a || test.b != got.b {
518 | 			t.Errorf("Parsing failed for %s, got a=%d, b=%d, want a=%d, b=%d", test.s, got.a, got.b, test.a, test.b)
519 | 		}
520 | 	}
521 | }
522 | 


--------------------------------------------------------------------------------
/queue.go:
--------------------------------------------------------------------------------
 1 | package css
 2 | 
 3 | // queue is a ring buffer implementation of a fixed size queue.
 4 | //
 5 | // This is an internal implementation aimed at queueing peeks into the token
 6 | // stream. Method intentionally panic when misused.
 7 | type queue struct {
 8 | 	vals  []token
 9 | 	start int
10 | 	n     int
11 | }
12 | 
13 | // newQueue creates a queue with a max of size elements. Any attempt to push
14 | // onto a full queue will panic.
15 | func newQueue(size int) *queue {
16 | 	return &queue{vals: make([]token, size)}
17 | }
18 | 
19 | // get returns the token n elements into the queue. get panics if there aren't
20 | // enough elements to satisfy the request.
21 | func (q *queue) get(n int) token {
22 | 	if n >= q.n {
23 | 		panic("queue: out of index lookup")
24 | 	}
25 | 	return q.vals[q.index(n)]
26 | }
27 | 
28 | // index is an internal method that returns the index of the particular offset,
29 | // performing the ring buffer logic.
30 | func (q *queue) index(n int) int {
31 | 	// Visual example of logic where 'x' is p.start and 'y' is the target index:
32 | 	//
33 | 	//   [_, x, _, _] start = 1, len = 4
34 | 	//   [_, x, y, _] n = 1, y = (1 + 1) % 4 = 2
35 | 	//   [_, x, _, y] n = 2, y = (1 + 2) % 4 = 3
36 | 	//   [y, x, _, _] n = 3, y = (1 + 3) % 4 = 0
37 | 	//
38 | 	return (q.start + n) % len(q.vals)
39 | }
40 | 
41 | // push enqueues an element. It panics if the queue is full.
42 | func (q *queue) push(t token) {
43 | 	if q.n == len(q.vals) {
44 | 		panic("queue: too many elements added to queue")
45 | 	}
46 | 	q.vals[q.index(q.n)] = t
47 | 	q.n++
48 | }
49 | 
50 | // pop dequeues an element. It panics if the queue is empty.
51 | func (q *queue) pop() token {
52 | 	if q.n == 0 {
53 | 		panic("queue: pop from an empty queue")
54 | 	}
55 | 	t := q.vals[q.start]
56 | 	q.start = q.index(1)
57 | 	q.n--
58 | 	return t
59 | }
60 | 
61 | func (q *queue) len() int {
62 | 	return q.n
63 | }
64 | 


--------------------------------------------------------------------------------
/queue_test.go:
--------------------------------------------------------------------------------
 1 | package css
 2 | 
 3 | import "testing"
 4 | 
 5 | func TestQueue(t *testing.T) {
 6 | 	t1 := token{tokenDelim, "*", "*", 0, 0, ""}
 7 | 	t2 := token{tokenIdent, "foo", "foo", 0, 0, ""}
 8 | 	t3 := token{tokenIdent, "bar", "bar", 0, 0, ""}
 9 | 	t4 := token{tokenIdent, "spam", "spam", 0, 0, ""}
10 | 
11 | 	_, _ = t3, t4
12 | 
13 | 	q := newQueue(2)
14 | 	q.push(t1)
15 | 	if got := q.get(0); got != t1 {
16 | 		t.Errorf("get(0) from queue with single element, got%#v, want=%#v", got, t1)
17 | 	}
18 | 	q.push(t2)
19 | 	if got := q.get(0); got != t1 {
20 | 		t.Errorf("get(0) from queue with two elements, got%#v, want=%#v", got, t1)
21 | 	}
22 | 	if got := q.get(1); got != t2 {
23 | 		t.Errorf("get(1) from queue with two elements, got%#v, want=%#v", got, t2)
24 | 	}
25 | 
26 | 	if got := q.pop(); got != t1 {
27 | 		t.Errorf("pop() from queue with two elements, got%#v, want=%#v", got, t1)
28 | 	}
29 | 	q.push(t3)
30 | 	if got := q.get(0); got != t2 {
31 | 		t.Errorf("get(0) from queue with two elements after requeue, got%#v, want=%#v", got, t2)
32 | 	}
33 | 	if got := q.get(1); got != t3 {
34 | 		t.Errorf("get(1) from queue with two elements after requeue, got%#v, want=%#v", got, t3)
35 | 	}
36 | 	if got := q.pop(); got != t2 {
37 | 		t.Errorf("pop() from queue with single element, got%#v, want=%#v", got, t1)
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/testdata/fuzz/FuzzParse/771e938e4458e983a736261a702e27c7a414fd660a15b63034f290b146d2f217:
--------------------------------------------------------------------------------
1 | go test fuzz v1
2 | string("0")
3 | 


--------------------------------------------------------------------------------
/testdata/fuzz/FuzzParse/78c19c977ebc4bbd1a8d570c4661a0bd5803195e4c805f7e32109d930b1ac85b:
--------------------------------------------------------------------------------
1 | go test fuzz v1
2 | string(":rLU((")
3 | 


--------------------------------------------------------------------------------
/testdata/fuzz/FuzzParse/ee189d6aaeb573cafd396e75348f04c44b83416d61cfca61c8446c5a41317cf8:
--------------------------------------------------------------------------------
1 | go test fuzz v1
2 | string("\xaa")
3 | 


--------------------------------------------------------------------------------
/testdata/fuzz/FuzzSelector/00e15d22123489fd:
--------------------------------------------------------------------------------
1 | go test fuzz v1
2 | string("0")
3 | string("0")
4 | 


--------------------------------------------------------------------------------