id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
600 |
aymerick/raymond
|
ast/node.go
|
LiteralStr
|
func LiteralStr(node Node) (string, bool) {
if lit, ok := node.(*StringLiteral); ok {
return lit.Value, true
}
if lit, ok := node.(*BooleanLiteral); ok {
return lit.Canonical(), true
}
if lit, ok := node.(*NumberLiteral); ok {
return lit.Canonical(), true
}
return "", false
}
|
go
|
func LiteralStr(node Node) (string, bool) {
if lit, ok := node.(*StringLiteral); ok {
return lit.Value, true
}
if lit, ok := node.(*BooleanLiteral); ok {
return lit.Canonical(), true
}
if lit, ok := node.(*NumberLiteral); ok {
return lit.Canonical(), true
}
return "", false
}
|
[
"func",
"LiteralStr",
"(",
"node",
"Node",
")",
"(",
"string",
",",
"bool",
")",
"{",
"if",
"lit",
",",
"ok",
":=",
"node",
".",
"(",
"*",
"StringLiteral",
")",
";",
"ok",
"{",
"return",
"lit",
".",
"Value",
",",
"true",
"\n",
"}",
"\n\n",
"if",
"lit",
",",
"ok",
":=",
"node",
".",
"(",
"*",
"BooleanLiteral",
")",
";",
"ok",
"{",
"return",
"lit",
".",
"Canonical",
"(",
")",
",",
"true",
"\n",
"}",
"\n\n",
"if",
"lit",
",",
"ok",
":=",
"node",
".",
"(",
"*",
"NumberLiteral",
")",
";",
"ok",
"{",
"return",
"lit",
".",
"Canonical",
"(",
")",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"false",
"\n",
"}"
] |
// LiteralStr returns the string representation of literal value, with a boolean set to false if this is not a literal.
|
[
"LiteralStr",
"returns",
"the",
"string",
"representation",
"of",
"literal",
"value",
"with",
"a",
"boolean",
"set",
"to",
"false",
"if",
"this",
"is",
"not",
"a",
"literal",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L475-L489
|
601 |
aymerick/raymond
|
ast/node.go
|
NewSubExpression
|
func NewSubExpression(pos int, line int) *SubExpression {
return &SubExpression{
NodeType: NodeSubExpression,
Loc: Loc{pos, line},
}
}
|
go
|
func NewSubExpression(pos int, line int) *SubExpression {
return &SubExpression{
NodeType: NodeSubExpression,
Loc: Loc{pos, line},
}
}
|
[
"func",
"NewSubExpression",
"(",
"pos",
"int",
",",
"line",
"int",
")",
"*",
"SubExpression",
"{",
"return",
"&",
"SubExpression",
"{",
"NodeType",
":",
"NodeSubExpression",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"}",
"\n",
"}"
] |
// NewSubExpression instanciates a new subexpression node.
|
[
"NewSubExpression",
"instanciates",
"a",
"new",
"subexpression",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L504-L509
|
602 |
aymerick/raymond
|
ast/node.go
|
NewPathExpression
|
func NewPathExpression(pos int, line int, data bool) *PathExpression {
result := &PathExpression{
NodeType: NodePath,
Loc: Loc{pos, line},
Data: data,
}
if data {
result.Original = "@"
}
return result
}
|
go
|
func NewPathExpression(pos int, line int, data bool) *PathExpression {
result := &PathExpression{
NodeType: NodePath,
Loc: Loc{pos, line},
Data: data,
}
if data {
result.Original = "@"
}
return result
}
|
[
"func",
"NewPathExpression",
"(",
"pos",
"int",
",",
"line",
"int",
",",
"data",
"bool",
")",
"*",
"PathExpression",
"{",
"result",
":=",
"&",
"PathExpression",
"{",
"NodeType",
":",
"NodePath",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"Data",
":",
"data",
",",
"}",
"\n\n",
"if",
"data",
"{",
"result",
".",
"Original",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// NewPathExpression instanciates a new path expression node.
|
[
"NewPathExpression",
"instanciates",
"a",
"new",
"path",
"expression",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L538-L551
|
603 |
aymerick/raymond
|
ast/node.go
|
Part
|
func (node *PathExpression) Part(part string) {
node.Original += part
switch part {
case "..":
node.Depth++
node.Scoped = true
case ".", "this":
node.Scoped = true
default:
node.Parts = append(node.Parts, part)
}
}
|
go
|
func (node *PathExpression) Part(part string) {
node.Original += part
switch part {
case "..":
node.Depth++
node.Scoped = true
case ".", "this":
node.Scoped = true
default:
node.Parts = append(node.Parts, part)
}
}
|
[
"func",
"(",
"node",
"*",
"PathExpression",
")",
"Part",
"(",
"part",
"string",
")",
"{",
"node",
".",
"Original",
"+=",
"part",
"\n\n",
"switch",
"part",
"{",
"case",
"\"",
"\"",
":",
"node",
".",
"Depth",
"++",
"\n",
"node",
".",
"Scoped",
"=",
"true",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"node",
".",
"Scoped",
"=",
"true",
"\n",
"default",
":",
"node",
".",
"Parts",
"=",
"append",
"(",
"node",
".",
"Parts",
",",
"part",
")",
"\n",
"}",
"\n",
"}"
] |
// Part adds path part.
|
[
"Part",
"adds",
"path",
"part",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L564-L576
|
604 |
aymerick/raymond
|
ast/node.go
|
NewStringLiteral
|
func NewStringLiteral(pos int, line int, val string) *StringLiteral {
return &StringLiteral{
NodeType: NodeString,
Loc: Loc{pos, line},
Value: val,
}
}
|
go
|
func NewStringLiteral(pos int, line int, val string) *StringLiteral {
return &StringLiteral{
NodeType: NodeString,
Loc: Loc{pos, line},
Value: val,
}
}
|
[
"func",
"NewStringLiteral",
"(",
"pos",
"int",
",",
"line",
"int",
",",
"val",
"string",
")",
"*",
"StringLiteral",
"{",
"return",
"&",
"StringLiteral",
"{",
"NodeType",
":",
"NodeString",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"Value",
":",
"val",
",",
"}",
"\n",
"}"
] |
// NewStringLiteral instanciates a new string node.
|
[
"NewStringLiteral",
"instanciates",
"a",
"new",
"string",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L601-L608
|
605 |
aymerick/raymond
|
ast/node.go
|
NewBooleanLiteral
|
func NewBooleanLiteral(pos int, line int, val bool, original string) *BooleanLiteral {
return &BooleanLiteral{
NodeType: NodeBoolean,
Loc: Loc{pos, line},
Value: val,
Original: original,
}
}
|
go
|
func NewBooleanLiteral(pos int, line int, val bool, original string) *BooleanLiteral {
return &BooleanLiteral{
NodeType: NodeBoolean,
Loc: Loc{pos, line},
Value: val,
Original: original,
}
}
|
[
"func",
"NewBooleanLiteral",
"(",
"pos",
"int",
",",
"line",
"int",
",",
"val",
"bool",
",",
"original",
"string",
")",
"*",
"BooleanLiteral",
"{",
"return",
"&",
"BooleanLiteral",
"{",
"NodeType",
":",
"NodeBoolean",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"Value",
":",
"val",
",",
"Original",
":",
"original",
",",
"}",
"\n",
"}"
] |
// NewBooleanLiteral instanciates a new boolean node.
|
[
"NewBooleanLiteral",
"instanciates",
"a",
"new",
"boolean",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L634-L642
|
606 |
aymerick/raymond
|
ast/node.go
|
NewNumberLiteral
|
func NewNumberLiteral(pos int, line int, val float64, isInt bool, original string) *NumberLiteral {
return &NumberLiteral{
NodeType: NodeNumber,
Loc: Loc{pos, line},
Value: val,
IsInt: isInt,
Original: original,
}
}
|
go
|
func NewNumberLiteral(pos int, line int, val float64, isInt bool, original string) *NumberLiteral {
return &NumberLiteral{
NodeType: NodeNumber,
Loc: Loc{pos, line},
Value: val,
IsInt: isInt,
Original: original,
}
}
|
[
"func",
"NewNumberLiteral",
"(",
"pos",
"int",
",",
"line",
"int",
",",
"val",
"float64",
",",
"isInt",
"bool",
",",
"original",
"string",
")",
"*",
"NumberLiteral",
"{",
"return",
"&",
"NumberLiteral",
"{",
"NodeType",
":",
"NodeNumber",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"Value",
":",
"val",
",",
"IsInt",
":",
"isInt",
",",
"Original",
":",
"original",
",",
"}",
"\n",
"}"
] |
// NewNumberLiteral instanciates a new number node.
|
[
"NewNumberLiteral",
"instanciates",
"a",
"new",
"number",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L678-L687
|
607 |
aymerick/raymond
|
ast/node.go
|
Number
|
func (node *NumberLiteral) Number() interface{} {
if node.IsInt {
return int(node.Value)
}
return node.Value
}
|
go
|
func (node *NumberLiteral) Number() interface{} {
if node.IsInt {
return int(node.Value)
}
return node.Value
}
|
[
"func",
"(",
"node",
"*",
"NumberLiteral",
")",
"Number",
"(",
")",
"interface",
"{",
"}",
"{",
"if",
"node",
".",
"IsInt",
"{",
"return",
"int",
"(",
"node",
".",
"Value",
")",
"\n",
"}",
"\n\n",
"return",
"node",
".",
"Value",
"\n",
"}"
] |
// Number returns an integer or a float.
|
[
"Number",
"returns",
"an",
"integer",
"or",
"a",
"float",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L709-L715
|
608 |
aymerick/raymond
|
ast/node.go
|
NewHash
|
func NewHash(pos int, line int) *Hash {
return &Hash{
NodeType: NodeHash,
Loc: Loc{pos, line},
}
}
|
go
|
func NewHash(pos int, line int) *Hash {
return &Hash{
NodeType: NodeHash,
Loc: Loc{pos, line},
}
}
|
[
"func",
"NewHash",
"(",
"pos",
"int",
",",
"line",
"int",
")",
"*",
"Hash",
"{",
"return",
"&",
"Hash",
"{",
"NodeType",
":",
"NodeHash",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"}",
"\n",
"}"
] |
// NewHash instanciates a new hash node.
|
[
"NewHash",
"instanciates",
"a",
"new",
"hash",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L730-L735
|
609 |
aymerick/raymond
|
ast/node.go
|
NewHashPair
|
func NewHashPair(pos int, line int) *HashPair {
return &HashPair{
NodeType: NodeHashPair,
Loc: Loc{pos, line},
}
}
|
go
|
func NewHashPair(pos int, line int) *HashPair {
return &HashPair{
NodeType: NodeHashPair,
Loc: Loc{pos, line},
}
}
|
[
"func",
"NewHashPair",
"(",
"pos",
"int",
",",
"line",
"int",
")",
"*",
"HashPair",
"{",
"return",
"&",
"HashPair",
"{",
"NodeType",
":",
"NodeHashPair",
",",
"Loc",
":",
"Loc",
"{",
"pos",
",",
"line",
"}",
",",
"}",
"\n",
"}"
] |
// NewHashPair instanciates a new hash pair node.
|
[
"NewHashPair",
"instanciates",
"a",
"new",
"hash",
"pair",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/ast/node.go#L770-L775
|
610 |
aymerick/raymond
|
parser/parser.go
|
Parse
|
func Parse(input string) (result *ast.Program, err error) {
// recover error
defer errRecover(&err)
parser := new(input)
// parse
result = parser.parseProgram()
// check last token
token := parser.shift()
if token.Kind != lexer.TokenEOF {
// Parsing ended before EOF
errToken(token, "Syntax error")
}
// fix whitespaces
processWhitespaces(result)
// named returned values
return
}
|
go
|
func Parse(input string) (result *ast.Program, err error) {
// recover error
defer errRecover(&err)
parser := new(input)
// parse
result = parser.parseProgram()
// check last token
token := parser.shift()
if token.Kind != lexer.TokenEOF {
// Parsing ended before EOF
errToken(token, "Syntax error")
}
// fix whitespaces
processWhitespaces(result)
// named returned values
return
}
|
[
"func",
"Parse",
"(",
"input",
"string",
")",
"(",
"result",
"*",
"ast",
".",
"Program",
",",
"err",
"error",
")",
"{",
"// recover error",
"defer",
"errRecover",
"(",
"&",
"err",
")",
"\n\n",
"parser",
":=",
"new",
"(",
"input",
")",
"\n\n",
"// parse",
"result",
"=",
"parser",
".",
"parseProgram",
"(",
")",
"\n\n",
"// check last token",
"token",
":=",
"parser",
".",
"shift",
"(",
")",
"\n",
"if",
"token",
".",
"Kind",
"!=",
"lexer",
".",
"TokenEOF",
"{",
"// Parsing ended before EOF",
"errToken",
"(",
"token",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// fix whitespaces",
"processWhitespaces",
"(",
"result",
")",
"\n\n",
"// named returned values",
"return",
"\n",
"}"
] |
// Parse analyzes given input and returns the AST root node.
|
[
"Parse",
"analyzes",
"given",
"input",
"and",
"returns",
"the",
"AST",
"root",
"node",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L47-L68
|
611 |
aymerick/raymond
|
parser/parser.go
|
errNode
|
func errNode(node ast.Node, msg string) {
errPanic(fmt.Errorf("%s\nNode: %s", msg, node), node.Location().Line)
}
|
go
|
func errNode(node ast.Node, msg string) {
errPanic(fmt.Errorf("%s\nNode: %s", msg, node), node.Location().Line)
}
|
[
"func",
"errNode",
"(",
"node",
"ast",
".",
"Node",
",",
"msg",
"string",
")",
"{",
"errPanic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\"",
",",
"msg",
",",
"node",
")",
",",
"node",
".",
"Location",
"(",
")",
".",
"Line",
")",
"\n",
"}"
] |
// errNode panics with given node infos
|
[
"errNode",
"panics",
"with",
"given",
"node",
"infos"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L91-L93
|
612 |
aymerick/raymond
|
parser/parser.go
|
errToken
|
func errToken(tok *lexer.Token, msg string) {
errPanic(fmt.Errorf("%s\nToken: %s", msg, tok), tok.Line)
}
|
go
|
func errToken(tok *lexer.Token, msg string) {
errPanic(fmt.Errorf("%s\nToken: %s", msg, tok), tok.Line)
}
|
[
"func",
"errToken",
"(",
"tok",
"*",
"lexer",
".",
"Token",
",",
"msg",
"string",
")",
"{",
"errPanic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\"",
",",
"msg",
",",
"tok",
")",
",",
"tok",
".",
"Line",
")",
"\n",
"}"
] |
// errNode panics with given Token infos
|
[
"errNode",
"panics",
"with",
"given",
"Token",
"infos"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L96-L98
|
613 |
aymerick/raymond
|
parser/parser.go
|
errExpected
|
func errExpected(expect lexer.TokenKind, tok *lexer.Token) {
errPanic(fmt.Errorf("Expecting %s, got: '%s'", expect, tok), tok.Line)
}
|
go
|
func errExpected(expect lexer.TokenKind, tok *lexer.Token) {
errPanic(fmt.Errorf("Expecting %s, got: '%s'", expect, tok), tok.Line)
}
|
[
"func",
"errExpected",
"(",
"expect",
"lexer",
".",
"TokenKind",
",",
"tok",
"*",
"lexer",
".",
"Token",
")",
"{",
"errPanic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"expect",
",",
"tok",
")",
",",
"tok",
".",
"Line",
")",
"\n",
"}"
] |
// errNode panics because of an unexpected Token kind
|
[
"errNode",
"panics",
"because",
"of",
"an",
"unexpected",
"Token",
"kind"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L101-L103
|
614 |
aymerick/raymond
|
parser/parser.go
|
isStatement
|
func (p *parser) isStatement() bool {
if !p.have(1) {
return false
}
switch p.next().Kind {
case lexer.TokenOpen, lexer.TokenOpenUnescaped, lexer.TokenOpenBlock,
lexer.TokenOpenInverse, lexer.TokenOpenRawBlock, lexer.TokenOpenPartial,
lexer.TokenContent, lexer.TokenComment:
return true
}
return false
}
|
go
|
func (p *parser) isStatement() bool {
if !p.have(1) {
return false
}
switch p.next().Kind {
case lexer.TokenOpen, lexer.TokenOpenUnescaped, lexer.TokenOpenBlock,
lexer.TokenOpenInverse, lexer.TokenOpenRawBlock, lexer.TokenOpenPartial,
lexer.TokenContent, lexer.TokenComment:
return true
}
return false
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"isStatement",
"(",
")",
"bool",
"{",
"if",
"!",
"p",
".",
"have",
"(",
"1",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"switch",
"p",
".",
"next",
"(",
")",
".",
"Kind",
"{",
"case",
"lexer",
".",
"TokenOpen",
",",
"lexer",
".",
"TokenOpenUnescaped",
",",
"lexer",
".",
"TokenOpenBlock",
",",
"lexer",
".",
"TokenOpenInverse",
",",
"lexer",
".",
"TokenOpenRawBlock",
",",
"lexer",
".",
"TokenOpenPartial",
",",
"lexer",
".",
"TokenContent",
",",
"lexer",
".",
"TokenComment",
":",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// isStatement returns true if next token starts a statement
|
[
"isStatement",
"returns",
"true",
"if",
"next",
"token",
"starts",
"a",
"statement"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L150-L163
|
615 |
aymerick/raymond
|
parser/parser.go
|
parseHelperNameOrSexpr
|
func (p *parser) parseHelperNameOrSexpr() ast.Node {
if p.isSexpr() {
// sexpr
return p.parseSexpr()
}
// helperName
return p.parseHelperName()
}
|
go
|
func (p *parser) parseHelperNameOrSexpr() ast.Node {
if p.isSexpr() {
// sexpr
return p.parseSexpr()
}
// helperName
return p.parseHelperName()
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseHelperNameOrSexpr",
"(",
")",
"ast",
".",
"Node",
"{",
"if",
"p",
".",
"isSexpr",
"(",
")",
"{",
"// sexpr",
"return",
"p",
".",
"parseSexpr",
"(",
")",
"\n",
"}",
"\n\n",
"// helperName",
"return",
"p",
".",
"parseHelperName",
"(",
")",
"\n",
"}"
] |
// helperName | sexpr
|
[
"helperName",
"|",
"sexpr"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L521-L529
|
616 |
aymerick/raymond
|
parser/parser.go
|
isParam
|
func (p *parser) isParam() bool {
return (p.isSexpr() || p.isHelperName()) && !p.isHashSegment()
}
|
go
|
func (p *parser) isParam() bool {
return (p.isSexpr() || p.isHelperName()) && !p.isHashSegment()
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"isParam",
"(",
")",
"bool",
"{",
"return",
"(",
"p",
".",
"isSexpr",
"(",
")",
"||",
"p",
".",
"isHelperName",
"(",
")",
")",
"&&",
"!",
"p",
".",
"isHashSegment",
"(",
")",
"\n",
"}"
] |
// Returns true if next tokens represent a `param`
|
[
"Returns",
"true",
"if",
"next",
"tokens",
"represent",
"a",
"param"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L537-L539
|
617 |
aymerick/raymond
|
parser/parser.go
|
isHashSegment
|
func (p *parser) isHashSegment() bool {
return p.have(2) && (p.next().Kind == lexer.TokenID) && (p.nextAt(1).Kind == lexer.TokenEquals)
}
|
go
|
func (p *parser) isHashSegment() bool {
return p.have(2) && (p.next().Kind == lexer.TokenID) && (p.nextAt(1).Kind == lexer.TokenEquals)
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"isHashSegment",
"(",
")",
"bool",
"{",
"return",
"p",
".",
"have",
"(",
"2",
")",
"&&",
"(",
"p",
".",
"next",
"(",
")",
".",
"Kind",
"==",
"lexer",
".",
"TokenID",
")",
"&&",
"(",
"p",
".",
"nextAt",
"(",
"1",
")",
".",
"Kind",
"==",
"lexer",
".",
"TokenEquals",
")",
"\n",
"}"
] |
// returns true if next tokens represents a `hashSegment`
|
[
"returns",
"true",
"if",
"next",
"tokens",
"represents",
"a",
"hashSegment"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L588-L590
|
618 |
aymerick/raymond
|
parser/parser.go
|
parseNumber
|
func parseNumber(tok *lexer.Token) (result float64, isInt bool) {
var valInt int
var err error
valInt, err = strconv.Atoi(tok.Val)
if err == nil {
isInt = true
result = float64(valInt)
} else {
isInt = false
result, err = strconv.ParseFloat(tok.Val, 64)
if err != nil {
errToken(tok, fmt.Sprintf("Failed to parse number: %s", tok.Val))
}
}
// named returned values
return
}
|
go
|
func parseNumber(tok *lexer.Token) (result float64, isInt bool) {
var valInt int
var err error
valInt, err = strconv.Atoi(tok.Val)
if err == nil {
isInt = true
result = float64(valInt)
} else {
isInt = false
result, err = strconv.ParseFloat(tok.Val, 64)
if err != nil {
errToken(tok, fmt.Sprintf("Failed to parse number: %s", tok.Val))
}
}
// named returned values
return
}
|
[
"func",
"parseNumber",
"(",
"tok",
"*",
"lexer",
".",
"Token",
")",
"(",
"result",
"float64",
",",
"isInt",
"bool",
")",
"{",
"var",
"valInt",
"int",
"\n",
"var",
"err",
"error",
"\n\n",
"valInt",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"tok",
".",
"Val",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"isInt",
"=",
"true",
"\n\n",
"result",
"=",
"float64",
"(",
"valInt",
")",
"\n",
"}",
"else",
"{",
"isInt",
"=",
"false",
"\n\n",
"result",
",",
"err",
"=",
"strconv",
".",
"ParseFloat",
"(",
"tok",
".",
"Val",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errToken",
"(",
"tok",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tok",
".",
"Val",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// named returned values",
"return",
"\n",
"}"
] |
// parseNumber parses a number
|
[
"parseNumber",
"parses",
"a",
"number"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L668-L688
|
619 |
aymerick/raymond
|
parser/parser.go
|
isHelperName
|
func (p *parser) isHelperName() bool {
switch p.next().Kind {
case lexer.TokenBoolean, lexer.TokenNumber, lexer.TokenString, lexer.TokenData, lexer.TokenID:
return true
}
return false
}
|
go
|
func (p *parser) isHelperName() bool {
switch p.next().Kind {
case lexer.TokenBoolean, lexer.TokenNumber, lexer.TokenString, lexer.TokenData, lexer.TokenID:
return true
}
return false
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"isHelperName",
"(",
")",
"bool",
"{",
"switch",
"p",
".",
"next",
"(",
")",
".",
"Kind",
"{",
"case",
"lexer",
".",
"TokenBoolean",
",",
"lexer",
".",
"TokenNumber",
",",
"lexer",
".",
"TokenString",
",",
"lexer",
".",
"TokenData",
",",
"lexer",
".",
"TokenID",
":",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// Returns true if next tokens represent a `helperName`
|
[
"Returns",
"true",
"if",
"next",
"tokens",
"represent",
"a",
"helperName"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L691-L698
|
620 |
aymerick/raymond
|
parser/parser.go
|
ensure
|
func (p *parser) ensure(index int) {
if p.lexOver {
// nothing more to grab
return
}
nb := index + 1
for len(p.tokens) < nb {
// fetch next token
tok := p.lex.NextToken()
// queue it
p.tokens = append(p.tokens, &tok)
if (tok.Kind == lexer.TokenEOF) || (tok.Kind == lexer.TokenError) {
p.lexOver = true
break
}
}
}
|
go
|
func (p *parser) ensure(index int) {
if p.lexOver {
// nothing more to grab
return
}
nb := index + 1
for len(p.tokens) < nb {
// fetch next token
tok := p.lex.NextToken()
// queue it
p.tokens = append(p.tokens, &tok)
if (tok.Kind == lexer.TokenEOF) || (tok.Kind == lexer.TokenError) {
p.lexOver = true
break
}
}
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"ensure",
"(",
"index",
"int",
")",
"{",
"if",
"p",
".",
"lexOver",
"{",
"// nothing more to grab",
"return",
"\n",
"}",
"\n\n",
"nb",
":=",
"index",
"+",
"1",
"\n\n",
"for",
"len",
"(",
"p",
".",
"tokens",
")",
"<",
"nb",
"{",
"// fetch next token",
"tok",
":=",
"p",
".",
"lex",
".",
"NextToken",
"(",
")",
"\n\n",
"// queue it",
"p",
".",
"tokens",
"=",
"append",
"(",
"p",
".",
"tokens",
",",
"&",
"tok",
")",
"\n\n",
"if",
"(",
"tok",
".",
"Kind",
"==",
"lexer",
".",
"TokenEOF",
")",
"||",
"(",
"tok",
".",
"Kind",
"==",
"lexer",
".",
"TokenError",
")",
"{",
"p",
".",
"lexOver",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Ensures there is token to parse at given index
|
[
"Ensures",
"there",
"is",
"token",
"to",
"parse",
"at",
"given",
"index"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L754-L774
|
621 |
aymerick/raymond
|
parser/parser.go
|
have
|
func (p *parser) have(nb int) bool {
p.ensure(nb - 1)
return len(p.tokens) >= nb
}
|
go
|
func (p *parser) have(nb int) bool {
p.ensure(nb - 1)
return len(p.tokens) >= nb
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"have",
"(",
"nb",
"int",
")",
"bool",
"{",
"p",
".",
"ensure",
"(",
"nb",
"-",
"1",
")",
"\n\n",
"return",
"len",
"(",
"p",
".",
"tokens",
")",
">=",
"nb",
"\n",
"}"
] |
// have returns true is there are a list given number of tokens to consume left
|
[
"have",
"returns",
"true",
"is",
"there",
"are",
"a",
"list",
"given",
"number",
"of",
"tokens",
"to",
"consume",
"left"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L777-L781
|
622 |
aymerick/raymond
|
parser/parser.go
|
nextAt
|
func (p *parser) nextAt(index int) *lexer.Token {
p.ensure(index)
return p.tokens[index]
}
|
go
|
func (p *parser) nextAt(index int) *lexer.Token {
p.ensure(index)
return p.tokens[index]
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"nextAt",
"(",
"index",
"int",
")",
"*",
"lexer",
".",
"Token",
"{",
"p",
".",
"ensure",
"(",
"index",
")",
"\n\n",
"return",
"p",
".",
"tokens",
"[",
"index",
"]",
"\n",
"}"
] |
// nextAt returns next token at given index, without consuming it
|
[
"nextAt",
"returns",
"next",
"token",
"at",
"given",
"index",
"without",
"consuming",
"it"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L784-L788
|
623 |
aymerick/raymond
|
parser/parser.go
|
shift
|
func (p *parser) shift() *lexer.Token {
var result *lexer.Token
p.ensure(0)
result, p.tokens = p.tokens[0], p.tokens[1:]
// check error token
if result.Kind == lexer.TokenError {
errToken(result, "Lexer error")
}
return result
}
|
go
|
func (p *parser) shift() *lexer.Token {
var result *lexer.Token
p.ensure(0)
result, p.tokens = p.tokens[0], p.tokens[1:]
// check error token
if result.Kind == lexer.TokenError {
errToken(result, "Lexer error")
}
return result
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"shift",
"(",
")",
"*",
"lexer",
".",
"Token",
"{",
"var",
"result",
"*",
"lexer",
".",
"Token",
"\n\n",
"p",
".",
"ensure",
"(",
"0",
")",
"\n\n",
"result",
",",
"p",
".",
"tokens",
"=",
"p",
".",
"tokens",
"[",
"0",
"]",
",",
"p",
".",
"tokens",
"[",
"1",
":",
"]",
"\n\n",
"// check error token",
"if",
"result",
".",
"Kind",
"==",
"lexer",
".",
"TokenError",
"{",
"errToken",
"(",
"result",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// shift returns next token and remove it from the tokens buffer
//
// Panics if next token is `TokenError`
|
[
"shift",
"returns",
"next",
"token",
"and",
"remove",
"it",
"from",
"the",
"tokens",
"buffer",
"Panics",
"if",
"next",
"token",
"is",
"TokenError"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L798-L811
|
624 |
aymerick/raymond
|
parser/parser.go
|
isToken
|
func (p *parser) isToken(kind lexer.TokenKind) bool {
return p.have(1) && p.next().Kind == kind
}
|
go
|
func (p *parser) isToken(kind lexer.TokenKind) bool {
return p.have(1) && p.next().Kind == kind
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"isToken",
"(",
"kind",
"lexer",
".",
"TokenKind",
")",
"bool",
"{",
"return",
"p",
".",
"have",
"(",
"1",
")",
"&&",
"p",
".",
"next",
"(",
")",
".",
"Kind",
"==",
"kind",
"\n",
"}"
] |
// isToken returns true if next token is of given type
|
[
"isToken",
"returns",
"true",
"if",
"next",
"token",
"is",
"of",
"given",
"type"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/parser/parser.go#L814-L816
|
625 |
aymerick/raymond
|
data_frame.go
|
Copy
|
func (p *DataFrame) Copy() *DataFrame {
result := NewDataFrame()
for k, v := range p.data {
result.data[k] = v
}
result.parent = p
return result
}
|
go
|
func (p *DataFrame) Copy() *DataFrame {
result := NewDataFrame()
for k, v := range p.data {
result.data[k] = v
}
result.parent = p
return result
}
|
[
"func",
"(",
"p",
"*",
"DataFrame",
")",
"Copy",
"(",
")",
"*",
"DataFrame",
"{",
"result",
":=",
"NewDataFrame",
"(",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"p",
".",
"data",
"{",
"result",
".",
"data",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"result",
".",
"parent",
"=",
"p",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// Copy instanciates a new private data frame with receiver as parent.
|
[
"Copy",
"instanciates",
"a",
"new",
"private",
"data",
"frame",
"with",
"receiver",
"as",
"parent",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/data_frame.go#L21-L31
|
626 |
aymerick/raymond
|
data_frame.go
|
newIterDataFrame
|
func (p *DataFrame) newIterDataFrame(length int, i int, key interface{}) *DataFrame {
result := p.Copy()
result.Set("index", i)
result.Set("key", key)
result.Set("first", i == 0)
result.Set("last", i == length-1)
return result
}
|
go
|
func (p *DataFrame) newIterDataFrame(length int, i int, key interface{}) *DataFrame {
result := p.Copy()
result.Set("index", i)
result.Set("key", key)
result.Set("first", i == 0)
result.Set("last", i == length-1)
return result
}
|
[
"func",
"(",
"p",
"*",
"DataFrame",
")",
"newIterDataFrame",
"(",
"length",
"int",
",",
"i",
"int",
",",
"key",
"interface",
"{",
"}",
")",
"*",
"DataFrame",
"{",
"result",
":=",
"p",
".",
"Copy",
"(",
")",
"\n\n",
"result",
".",
"Set",
"(",
"\"",
"\"",
",",
"i",
")",
"\n",
"result",
".",
"Set",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"result",
".",
"Set",
"(",
"\"",
"\"",
",",
"i",
"==",
"0",
")",
"\n",
"result",
".",
"Set",
"(",
"\"",
"\"",
",",
"i",
"==",
"length",
"-",
"1",
")",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// newIterDataFrame instanciates a new private data frame with receiver as parent and with iteration data set (@index, @key, @first, @last)
|
[
"newIterDataFrame",
"instanciates",
"a",
"new",
"private",
"data",
"frame",
"with",
"receiver",
"as",
"parent",
"and",
"with",
"iteration",
"data",
"set",
"("
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/data_frame.go#L34-L43
|
627 |
aymerick/raymond
|
data_frame.go
|
Set
|
func (p *DataFrame) Set(key string, val interface{}) {
p.data[key] = val
}
|
go
|
func (p *DataFrame) Set(key string, val interface{}) {
p.data[key] = val
}
|
[
"func",
"(",
"p",
"*",
"DataFrame",
")",
"Set",
"(",
"key",
"string",
",",
"val",
"interface",
"{",
"}",
")",
"{",
"p",
".",
"data",
"[",
"key",
"]",
"=",
"val",
"\n",
"}"
] |
// Set sets a data value.
|
[
"Set",
"sets",
"a",
"data",
"value",
"."
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/data_frame.go#L46-L48
|
628 |
aymerick/raymond
|
data_frame.go
|
find
|
func (p *DataFrame) find(parts []string) interface{} {
data := p.data
for i, part := range parts {
val := data[part]
if val == nil {
return nil
}
if i == len(parts)-1 {
// found
return val
}
valValue := reflect.ValueOf(val)
if valValue.Kind() != reflect.Map {
// not found
return nil
}
// continue
data = mapStringInterface(valValue)
}
// not found
return nil
}
|
go
|
func (p *DataFrame) find(parts []string) interface{} {
data := p.data
for i, part := range parts {
val := data[part]
if val == nil {
return nil
}
if i == len(parts)-1 {
// found
return val
}
valValue := reflect.ValueOf(val)
if valValue.Kind() != reflect.Map {
// not found
return nil
}
// continue
data = mapStringInterface(valValue)
}
// not found
return nil
}
|
[
"func",
"(",
"p",
"*",
"DataFrame",
")",
"find",
"(",
"parts",
"[",
"]",
"string",
")",
"interface",
"{",
"}",
"{",
"data",
":=",
"p",
".",
"data",
"\n\n",
"for",
"i",
",",
"part",
":=",
"range",
"parts",
"{",
"val",
":=",
"data",
"[",
"part",
"]",
"\n",
"if",
"val",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"i",
"==",
"len",
"(",
"parts",
")",
"-",
"1",
"{",
"// found",
"return",
"val",
"\n",
"}",
"\n\n",
"valValue",
":=",
"reflect",
".",
"ValueOf",
"(",
"val",
")",
"\n",
"if",
"valValue",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Map",
"{",
"// not found",
"return",
"nil",
"\n",
"}",
"\n\n",
"// continue",
"data",
"=",
"mapStringInterface",
"(",
"valValue",
")",
"\n",
"}",
"\n\n",
"// not found",
"return",
"nil",
"\n",
"}"
] |
// find gets a deep data value
//
// @todo This is NOT consistent with the way we resolve data in template (cf. `evalDataPathExpression()`) ! FIX THAT !
|
[
"find",
"gets",
"a",
"deep",
"data",
"value"
] |
b565731e1464263de0bda75f2e45d97b54b60110
|
https://github.com/aymerick/raymond/blob/b565731e1464263de0bda75f2e45d97b54b60110/data_frame.go#L58-L84
|
629 |
valyala/gorpc
|
dispatcher.go
|
NewBatch
|
func (dc *DispatcherClient) NewBatch() *DispatcherBatch {
return &DispatcherBatch{
c: dc,
b: dc.c.NewBatch(),
}
}
|
go
|
func (dc *DispatcherClient) NewBatch() *DispatcherBatch {
return &DispatcherBatch{
c: dc,
b: dc.c.NewBatch(),
}
}
|
[
"func",
"(",
"dc",
"*",
"DispatcherClient",
")",
"NewBatch",
"(",
")",
"*",
"DispatcherBatch",
"{",
"return",
"&",
"DispatcherBatch",
"{",
"c",
":",
"dc",
",",
"b",
":",
"dc",
".",
"c",
".",
"NewBatch",
"(",
")",
",",
"}",
"\n",
"}"
] |
// NewBatch creates new RPC batch for the given DispatcherClient.
//
// It is safe creating multiple concurrent batches from a single client.
|
[
"NewBatch",
"creates",
"new",
"RPC",
"batch",
"for",
"the",
"given",
"DispatcherClient",
".",
"It",
"is",
"safe",
"creating",
"multiple",
"concurrent",
"batches",
"from",
"a",
"single",
"client",
"."
] |
908281bef77441f2d0ec1792189b4032a1dace0c
|
https://github.com/valyala/gorpc/blob/908281bef77441f2d0ec1792189b4032a1dace0c/dispatcher.go#L543-L548
|
630 |
valyala/gorpc
|
client.go
|
Stop
|
func (c *Client) Stop() {
if c.clientStopChan == nil {
panic("gorpc.Client: the client must be started before stopping it")
}
close(c.clientStopChan)
c.stopWg.Wait()
c.clientStopChan = nil
}
|
go
|
func (c *Client) Stop() {
if c.clientStopChan == nil {
panic("gorpc.Client: the client must be started before stopping it")
}
close(c.clientStopChan)
c.stopWg.Wait()
c.clientStopChan = nil
}
|
[
"func",
"(",
"c",
"*",
"Client",
")",
"Stop",
"(",
")",
"{",
"if",
"c",
".",
"clientStopChan",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"close",
"(",
"c",
".",
"clientStopChan",
")",
"\n",
"c",
".",
"stopWg",
".",
"Wait",
"(",
")",
"\n",
"c",
".",
"clientStopChan",
"=",
"nil",
"\n",
"}"
] |
// Stop stops rpc client. Stopped client can be started again.
|
[
"Stop",
"stops",
"rpc",
"client",
".",
"Stopped",
"client",
"can",
"be",
"started",
"again",
"."
] |
908281bef77441f2d0ec1792189b4032a1dace0c
|
https://github.com/valyala/gorpc/blob/908281bef77441f2d0ec1792189b4032a1dace0c/client.go#L162-L169
|
631 |
valyala/gorpc
|
server.go
|
Stop
|
func (s *Server) Stop() {
if s.serverStopChan == nil {
panic("gorpc.Server: server must be started before stopping it")
}
close(s.serverStopChan)
s.stopWg.Wait()
s.serverStopChan = nil
}
|
go
|
func (s *Server) Stop() {
if s.serverStopChan == nil {
panic("gorpc.Server: server must be started before stopping it")
}
close(s.serverStopChan)
s.stopWg.Wait()
s.serverStopChan = nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Stop",
"(",
")",
"{",
"if",
"s",
".",
"serverStopChan",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"close",
"(",
"s",
".",
"serverStopChan",
")",
"\n",
"s",
".",
"stopWg",
".",
"Wait",
"(",
")",
"\n",
"s",
".",
"serverStopChan",
"=",
"nil",
"\n",
"}"
] |
// Stop stops rpc server. Stopped server can be started again.
|
[
"Stop",
"stops",
"rpc",
"server",
".",
"Stopped",
"server",
"can",
"be",
"started",
"again",
"."
] |
908281bef77441f2d0ec1792189b4032a1dace0c
|
https://github.com/valyala/gorpc/blob/908281bef77441f2d0ec1792189b4032a1dace0c/server.go#L163-L170
|
632 |
valyala/gorpc
|
server.go
|
Serve
|
func (s *Server) Serve() error {
if err := s.Start(); err != nil {
return err
}
s.stopWg.Wait()
return nil
}
|
go
|
func (s *Server) Serve() error {
if err := s.Start(); err != nil {
return err
}
s.stopWg.Wait()
return nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Serve",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"s",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
".",
"stopWg",
".",
"Wait",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Serve starts rpc server and blocks until it is stopped.
|
[
"Serve",
"starts",
"rpc",
"server",
"and",
"blocks",
"until",
"it",
"is",
"stopped",
"."
] |
908281bef77441f2d0ec1792189b4032a1dace0c
|
https://github.com/valyala/gorpc/blob/908281bef77441f2d0ec1792189b4032a1dace0c/server.go#L173-L179
|
633 |
shiena/ansicolor
|
ansicolor.go
|
NewModeAnsiColorWriter
|
func NewModeAnsiColorWriter(w io.Writer, mode outputMode) io.Writer {
if _, ok := w.(*ansiColorWriter); !ok {
return &ansiColorWriter{
w: w,
mode: mode,
}
}
return w
}
|
go
|
func NewModeAnsiColorWriter(w io.Writer, mode outputMode) io.Writer {
if _, ok := w.(*ansiColorWriter); !ok {
return &ansiColorWriter{
w: w,
mode: mode,
}
}
return w
}
|
[
"func",
"NewModeAnsiColorWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"mode",
"outputMode",
")",
"io",
".",
"Writer",
"{",
"if",
"_",
",",
"ok",
":=",
"w",
".",
"(",
"*",
"ansiColorWriter",
")",
";",
"!",
"ok",
"{",
"return",
"&",
"ansiColorWriter",
"{",
"w",
":",
"w",
",",
"mode",
":",
"mode",
",",
"}",
"\n",
"}",
"\n",
"return",
"w",
"\n",
"}"
] |
// NewModeAnsiColorWriter create and initializes a new ansiColorWriter
// by specifying the outputMode.
|
[
"NewModeAnsiColorWriter",
"create",
"and",
"initializes",
"a",
"new",
"ansiColorWriter",
"by",
"specifying",
"the",
"outputMode",
"."
] |
a422bbe96644373c5753384a59d678f7d261ff10
|
https://github.com/shiena/ansicolor/blob/a422bbe96644373c5753384a59d678f7d261ff10/ansicolor.go#L34-L42
|
634 |
andybalholm/cascadia
|
parser.go
|
parseEscape
|
func (p *parser) parseEscape() (result string, err error) {
if len(p.s) < p.i+2 || p.s[p.i] != '\\' {
return "", errors.New("invalid escape sequence")
}
start := p.i + 1
c := p.s[start]
switch {
case c == '\r' || c == '\n' || c == '\f':
return "", errors.New("escaped line ending outside string")
case hexDigit(c):
// unicode escape (hex)
var i int
for i = start; i < p.i+6 && i < len(p.s) && hexDigit(p.s[i]); i++ {
// empty
}
v, _ := strconv.ParseUint(p.s[start:i], 16, 21)
if len(p.s) > i {
switch p.s[i] {
case '\r':
i++
if len(p.s) > i && p.s[i] == '\n' {
i++
}
case ' ', '\t', '\n', '\f':
i++
}
}
p.i = i
return string(rune(v)), nil
}
// Return the literal character after the backslash.
result = p.s[start : start+1]
p.i += 2
return result, nil
}
|
go
|
func (p *parser) parseEscape() (result string, err error) {
if len(p.s) < p.i+2 || p.s[p.i] != '\\' {
return "", errors.New("invalid escape sequence")
}
start := p.i + 1
c := p.s[start]
switch {
case c == '\r' || c == '\n' || c == '\f':
return "", errors.New("escaped line ending outside string")
case hexDigit(c):
// unicode escape (hex)
var i int
for i = start; i < p.i+6 && i < len(p.s) && hexDigit(p.s[i]); i++ {
// empty
}
v, _ := strconv.ParseUint(p.s[start:i], 16, 21)
if len(p.s) > i {
switch p.s[i] {
case '\r':
i++
if len(p.s) > i && p.s[i] == '\n' {
i++
}
case ' ', '\t', '\n', '\f':
i++
}
}
p.i = i
return string(rune(v)), nil
}
// Return the literal character after the backslash.
result = p.s[start : start+1]
p.i += 2
return result, nil
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseEscape",
"(",
")",
"(",
"result",
"string",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"p",
".",
"s",
")",
"<",
"p",
".",
"i",
"+",
"2",
"||",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"!=",
"'\\\\'",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"start",
":=",
"p",
".",
"i",
"+",
"1",
"\n",
"c",
":=",
"p",
".",
"s",
"[",
"start",
"]",
"\n",
"switch",
"{",
"case",
"c",
"==",
"'\\r'",
"||",
"c",
"==",
"'\\n'",
"||",
"c",
"==",
"'\\f'",
":",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"case",
"hexDigit",
"(",
"c",
")",
":",
"// unicode escape (hex)",
"var",
"i",
"int",
"\n",
"for",
"i",
"=",
"start",
";",
"i",
"<",
"p",
".",
"i",
"+",
"6",
"&&",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"&&",
"hexDigit",
"(",
"p",
".",
"s",
"[",
"i",
"]",
")",
";",
"i",
"++",
"{",
"// empty",
"}",
"\n",
"v",
",",
"_",
":=",
"strconv",
".",
"ParseUint",
"(",
"p",
".",
"s",
"[",
"start",
":",
"i",
"]",
",",
"16",
",",
"21",
")",
"\n",
"if",
"len",
"(",
"p",
".",
"s",
")",
">",
"i",
"{",
"switch",
"p",
".",
"s",
"[",
"i",
"]",
"{",
"case",
"'\\r'",
":",
"i",
"++",
"\n",
"if",
"len",
"(",
"p",
".",
"s",
")",
">",
"i",
"&&",
"p",
".",
"s",
"[",
"i",
"]",
"==",
"'\\n'",
"{",
"i",
"++",
"\n",
"}",
"\n",
"case",
"' '",
",",
"'\\t'",
",",
"'\\n'",
",",
"'\\f'",
":",
"i",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"p",
".",
"i",
"=",
"i",
"\n",
"return",
"string",
"(",
"rune",
"(",
"v",
")",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"// Return the literal character after the backslash.",
"result",
"=",
"p",
".",
"s",
"[",
"start",
":",
"start",
"+",
"1",
"]",
"\n",
"p",
".",
"i",
"+=",
"2",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// parseEscape parses a backslash escape.
|
[
"parseEscape",
"parses",
"a",
"backslash",
"escape",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L21-L57
|
635 |
andybalholm/cascadia
|
parser.go
|
parseIdentifier
|
func (p *parser) parseIdentifier() (result string, err error) {
startingDash := false
if len(p.s) > p.i && p.s[p.i] == '-' {
startingDash = true
p.i++
}
if len(p.s) <= p.i {
return "", errors.New("expected identifier, found EOF instead")
}
if c := p.s[p.i]; !(nameStart(c) || c == '\\') {
return "", fmt.Errorf("expected identifier, found %c instead", c)
}
result, err = p.parseName()
if startingDash && err == nil {
result = "-" + result
}
return
}
|
go
|
func (p *parser) parseIdentifier() (result string, err error) {
startingDash := false
if len(p.s) > p.i && p.s[p.i] == '-' {
startingDash = true
p.i++
}
if len(p.s) <= p.i {
return "", errors.New("expected identifier, found EOF instead")
}
if c := p.s[p.i]; !(nameStart(c) || c == '\\') {
return "", fmt.Errorf("expected identifier, found %c instead", c)
}
result, err = p.parseName()
if startingDash && err == nil {
result = "-" + result
}
return
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseIdentifier",
"(",
")",
"(",
"result",
"string",
",",
"err",
"error",
")",
"{",
"startingDash",
":=",
"false",
"\n",
"if",
"len",
"(",
"p",
".",
"s",
")",
">",
"p",
".",
"i",
"&&",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"==",
"'-'",
"{",
"startingDash",
"=",
"true",
"\n",
"p",
".",
"i",
"++",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"p",
".",
"s",
")",
"<=",
"p",
".",
"i",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"c",
":=",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
";",
"!",
"(",
"nameStart",
"(",
"c",
")",
"||",
"c",
"==",
"'\\\\'",
")",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"}",
"\n\n",
"result",
",",
"err",
"=",
"p",
".",
"parseName",
"(",
")",
"\n",
"if",
"startingDash",
"&&",
"err",
"==",
"nil",
"{",
"result",
"=",
"\"",
"\"",
"+",
"result",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// parseIdentifier parses an identifier.
|
[
"parseIdentifier",
"parses",
"an",
"identifier",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L77-L97
|
636 |
andybalholm/cascadia
|
parser.go
|
parseString
|
func (p *parser) parseString() (result string, err error) {
i := p.i
if len(p.s) < i+2 {
return "", errors.New("expected string, found EOF instead")
}
quote := p.s[i]
i++
loop:
for i < len(p.s) {
switch p.s[i] {
case '\\':
if len(p.s) > i+1 {
switch c := p.s[i+1]; c {
case '\r':
if len(p.s) > i+2 && p.s[i+2] == '\n' {
i += 3
continue loop
}
fallthrough
case '\n', '\f':
i += 2
continue loop
}
}
p.i = i
val, err := p.parseEscape()
if err != nil {
return "", err
}
i = p.i
result += val
case quote:
break loop
case '\r', '\n', '\f':
return "", errors.New("unexpected end of line in string")
default:
start := i
for i < len(p.s) {
if c := p.s[i]; c == quote || c == '\\' || c == '\r' || c == '\n' || c == '\f' {
break
}
i++
}
result += p.s[start:i]
}
}
if i >= len(p.s) {
return "", errors.New("EOF in string")
}
// Consume the final quote.
i++
p.i = i
return result, nil
}
|
go
|
func (p *parser) parseString() (result string, err error) {
i := p.i
if len(p.s) < i+2 {
return "", errors.New("expected string, found EOF instead")
}
quote := p.s[i]
i++
loop:
for i < len(p.s) {
switch p.s[i] {
case '\\':
if len(p.s) > i+1 {
switch c := p.s[i+1]; c {
case '\r':
if len(p.s) > i+2 && p.s[i+2] == '\n' {
i += 3
continue loop
}
fallthrough
case '\n', '\f':
i += 2
continue loop
}
}
p.i = i
val, err := p.parseEscape()
if err != nil {
return "", err
}
i = p.i
result += val
case quote:
break loop
case '\r', '\n', '\f':
return "", errors.New("unexpected end of line in string")
default:
start := i
for i < len(p.s) {
if c := p.s[i]; c == quote || c == '\\' || c == '\r' || c == '\n' || c == '\f' {
break
}
i++
}
result += p.s[start:i]
}
}
if i >= len(p.s) {
return "", errors.New("EOF in string")
}
// Consume the final quote.
i++
p.i = i
return result, nil
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseString",
"(",
")",
"(",
"result",
"string",
",",
"err",
"error",
")",
"{",
"i",
":=",
"p",
".",
"i",
"\n",
"if",
"len",
"(",
"p",
".",
"s",
")",
"<",
"i",
"+",
"2",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"quote",
":=",
"p",
".",
"s",
"[",
"i",
"]",
"\n",
"i",
"++",
"\n\n",
"loop",
":",
"for",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"{",
"switch",
"p",
".",
"s",
"[",
"i",
"]",
"{",
"case",
"'\\\\'",
":",
"if",
"len",
"(",
"p",
".",
"s",
")",
">",
"i",
"+",
"1",
"{",
"switch",
"c",
":=",
"p",
".",
"s",
"[",
"i",
"+",
"1",
"]",
";",
"c",
"{",
"case",
"'\\r'",
":",
"if",
"len",
"(",
"p",
".",
"s",
")",
">",
"i",
"+",
"2",
"&&",
"p",
".",
"s",
"[",
"i",
"+",
"2",
"]",
"==",
"'\\n'",
"{",
"i",
"+=",
"3",
"\n",
"continue",
"loop",
"\n",
"}",
"\n",
"fallthrough",
"\n",
"case",
"'\\n'",
",",
"'\\f'",
":",
"i",
"+=",
"2",
"\n",
"continue",
"loop",
"\n",
"}",
"\n",
"}",
"\n",
"p",
".",
"i",
"=",
"i",
"\n",
"val",
",",
"err",
":=",
"p",
".",
"parseEscape",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"i",
"=",
"p",
".",
"i",
"\n",
"result",
"+=",
"val",
"\n",
"case",
"quote",
":",
"break",
"loop",
"\n",
"case",
"'\\r'",
",",
"'\\n'",
",",
"'\\f'",
":",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"start",
":=",
"i",
"\n",
"for",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"{",
"if",
"c",
":=",
"p",
".",
"s",
"[",
"i",
"]",
";",
"c",
"==",
"quote",
"||",
"c",
"==",
"'\\\\'",
"||",
"c",
"==",
"'\\r'",
"||",
"c",
"==",
"'\\n'",
"||",
"c",
"==",
"'\\f'",
"{",
"break",
"\n",
"}",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"result",
"+=",
"p",
".",
"s",
"[",
"start",
":",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"i",
">=",
"len",
"(",
"p",
".",
"s",
")",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Consume the final quote.",
"i",
"++",
"\n\n",
"p",
".",
"i",
"=",
"i",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// parseString parses a single- or double-quoted string.
|
[
"parseString",
"parses",
"a",
"single",
"-",
"or",
"double",
"-",
"quoted",
"string",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L135-L193
|
637 |
andybalholm/cascadia
|
parser.go
|
parseRegex
|
func (p *parser) parseRegex() (rx *regexp.Regexp, err error) {
i := p.i
if len(p.s) < i+2 {
return nil, errors.New("expected regular expression, found EOF instead")
}
// number of open parens or brackets;
// when it becomes negative, finished parsing regex
open := 0
loop:
for i < len(p.s) {
switch p.s[i] {
case '(', '[':
open++
case ')', ']':
open--
if open < 0 {
break loop
}
}
i++
}
if i >= len(p.s) {
return nil, errors.New("EOF in regular expression")
}
rx, err = regexp.Compile(p.s[p.i:i])
p.i = i
return rx, err
}
|
go
|
func (p *parser) parseRegex() (rx *regexp.Regexp, err error) {
i := p.i
if len(p.s) < i+2 {
return nil, errors.New("expected regular expression, found EOF instead")
}
// number of open parens or brackets;
// when it becomes negative, finished parsing regex
open := 0
loop:
for i < len(p.s) {
switch p.s[i] {
case '(', '[':
open++
case ')', ']':
open--
if open < 0 {
break loop
}
}
i++
}
if i >= len(p.s) {
return nil, errors.New("EOF in regular expression")
}
rx, err = regexp.Compile(p.s[p.i:i])
p.i = i
return rx, err
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseRegex",
"(",
")",
"(",
"rx",
"*",
"regexp",
".",
"Regexp",
",",
"err",
"error",
")",
"{",
"i",
":=",
"p",
".",
"i",
"\n",
"if",
"len",
"(",
"p",
".",
"s",
")",
"<",
"i",
"+",
"2",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// number of open parens or brackets;",
"// when it becomes negative, finished parsing regex",
"open",
":=",
"0",
"\n\n",
"loop",
":",
"for",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"{",
"switch",
"p",
".",
"s",
"[",
"i",
"]",
"{",
"case",
"'('",
",",
"'['",
":",
"open",
"++",
"\n",
"case",
"')'",
",",
"']'",
":",
"open",
"--",
"\n",
"if",
"open",
"<",
"0",
"{",
"break",
"loop",
"\n",
"}",
"\n",
"}",
"\n",
"i",
"++",
"\n",
"}",
"\n\n",
"if",
"i",
">=",
"len",
"(",
"p",
".",
"s",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"rx",
",",
"err",
"=",
"regexp",
".",
"Compile",
"(",
"p",
".",
"s",
"[",
"p",
".",
"i",
":",
"i",
"]",
")",
"\n",
"p",
".",
"i",
"=",
"i",
"\n",
"return",
"rx",
",",
"err",
"\n",
"}"
] |
// parseRegex parses a regular expression; the end is defined by encountering an
// unmatched closing ')' or ']' which is not consumed
|
[
"parseRegex",
"parses",
"a",
"regular",
"expression",
";",
"the",
"end",
"is",
"defined",
"by",
"encountering",
"an",
"unmatched",
"closing",
")",
"or",
"]",
"which",
"is",
"not",
"consumed"
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L197-L227
|
638 |
andybalholm/cascadia
|
parser.go
|
skipWhitespace
|
func (p *parser) skipWhitespace() bool {
i := p.i
for i < len(p.s) {
switch p.s[i] {
case ' ', '\t', '\r', '\n', '\f':
i++
continue
case '/':
if strings.HasPrefix(p.s[i:], "/*") {
end := strings.Index(p.s[i+len("/*"):], "*/")
if end != -1 {
i += end + len("/**/")
continue
}
}
}
break
}
if i > p.i {
p.i = i
return true
}
return false
}
|
go
|
func (p *parser) skipWhitespace() bool {
i := p.i
for i < len(p.s) {
switch p.s[i] {
case ' ', '\t', '\r', '\n', '\f':
i++
continue
case '/':
if strings.HasPrefix(p.s[i:], "/*") {
end := strings.Index(p.s[i+len("/*"):], "*/")
if end != -1 {
i += end + len("/**/")
continue
}
}
}
break
}
if i > p.i {
p.i = i
return true
}
return false
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"skipWhitespace",
"(",
")",
"bool",
"{",
"i",
":=",
"p",
".",
"i",
"\n",
"for",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"{",
"switch",
"p",
".",
"s",
"[",
"i",
"]",
"{",
"case",
"' '",
",",
"'\\t'",
",",
"'\\r'",
",",
"'\\n'",
",",
"'\\f'",
":",
"i",
"++",
"\n",
"continue",
"\n",
"case",
"'/'",
":",
"if",
"strings",
".",
"HasPrefix",
"(",
"p",
".",
"s",
"[",
"i",
":",
"]",
",",
"\"",
"\"",
")",
"{",
"end",
":=",
"strings",
".",
"Index",
"(",
"p",
".",
"s",
"[",
"i",
"+",
"len",
"(",
"\"",
"\"",
")",
":",
"]",
",",
"\"",
"\"",
")",
"\n",
"if",
"end",
"!=",
"-",
"1",
"{",
"i",
"+=",
"end",
"+",
"len",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n\n",
"if",
"i",
">",
"p",
".",
"i",
"{",
"p",
".",
"i",
"=",
"i",
"\n",
"return",
"true",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// skipWhitespace consumes whitespace characters and comments.
// It returns true if there was actually anything to skip.
|
[
"skipWhitespace",
"consumes",
"whitespace",
"characters",
"and",
"comments",
".",
"It",
"returns",
"true",
"if",
"there",
"was",
"actually",
"anything",
"to",
"skip",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L231-L256
|
639 |
andybalholm/cascadia
|
parser.go
|
consumeParenthesis
|
func (p *parser) consumeParenthesis() bool {
if p.i < len(p.s) && p.s[p.i] == '(' {
p.i++
p.skipWhitespace()
return true
}
return false
}
|
go
|
func (p *parser) consumeParenthesis() bool {
if p.i < len(p.s) && p.s[p.i] == '(' {
p.i++
p.skipWhitespace()
return true
}
return false
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"consumeParenthesis",
"(",
")",
"bool",
"{",
"if",
"p",
".",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"&&",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"==",
"'('",
"{",
"p",
".",
"i",
"++",
"\n",
"p",
".",
"skipWhitespace",
"(",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// consumeParenthesis consumes an opening parenthesis and any following
// whitespace. It returns true if there was actually a parenthesis to skip.
|
[
"consumeParenthesis",
"consumes",
"an",
"opening",
"parenthesis",
"and",
"any",
"following",
"whitespace",
".",
"It",
"returns",
"true",
"if",
"there",
"was",
"actually",
"a",
"parenthesis",
"to",
"skip",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L260-L267
|
640 |
andybalholm/cascadia
|
parser.go
|
consumeClosingParenthesis
|
func (p *parser) consumeClosingParenthesis() bool {
i := p.i
p.skipWhitespace()
if p.i < len(p.s) && p.s[p.i] == ')' {
p.i++
return true
}
p.i = i
return false
}
|
go
|
func (p *parser) consumeClosingParenthesis() bool {
i := p.i
p.skipWhitespace()
if p.i < len(p.s) && p.s[p.i] == ')' {
p.i++
return true
}
p.i = i
return false
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"consumeClosingParenthesis",
"(",
")",
"bool",
"{",
"i",
":=",
"p",
".",
"i",
"\n",
"p",
".",
"skipWhitespace",
"(",
")",
"\n",
"if",
"p",
".",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"&&",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"==",
"')'",
"{",
"p",
".",
"i",
"++",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"p",
".",
"i",
"=",
"i",
"\n",
"return",
"false",
"\n",
"}"
] |
// consumeClosingParenthesis consumes a closing parenthesis and any preceding
// whitespace. It returns true if there was actually a parenthesis to skip.
|
[
"consumeClosingParenthesis",
"consumes",
"a",
"closing",
"parenthesis",
"and",
"any",
"preceding",
"whitespace",
".",
"It",
"returns",
"true",
"if",
"there",
"was",
"actually",
"a",
"parenthesis",
"to",
"skip",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L271-L280
|
641 |
andybalholm/cascadia
|
parser.go
|
parseIDSelector
|
func (p *parser) parseIDSelector() (Selector, error) {
if p.i >= len(p.s) {
return nil, fmt.Errorf("expected id selector (#id), found EOF instead")
}
if p.s[p.i] != '#' {
return nil, fmt.Errorf("expected id selector (#id), found '%c' instead", p.s[p.i])
}
p.i++
id, err := p.parseName()
if err != nil {
return nil, err
}
return attributeEqualsSelector("id", id), nil
}
|
go
|
func (p *parser) parseIDSelector() (Selector, error) {
if p.i >= len(p.s) {
return nil, fmt.Errorf("expected id selector (#id), found EOF instead")
}
if p.s[p.i] != '#' {
return nil, fmt.Errorf("expected id selector (#id), found '%c' instead", p.s[p.i])
}
p.i++
id, err := p.parseName()
if err != nil {
return nil, err
}
return attributeEqualsSelector("id", id), nil
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseIDSelector",
"(",
")",
"(",
"Selector",
",",
"error",
")",
"{",
"if",
"p",
".",
"i",
">=",
"len",
"(",
"p",
".",
"s",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"!=",
"'#'",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
")",
"\n",
"}",
"\n\n",
"p",
".",
"i",
"++",
"\n",
"id",
",",
"err",
":=",
"p",
".",
"parseName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"attributeEqualsSelector",
"(",
"\"",
"\"",
",",
"id",
")",
",",
"nil",
"\n",
"}"
] |
// parseIDSelector parses a selector that matches by id attribute.
|
[
"parseIDSelector",
"parses",
"a",
"selector",
"that",
"matches",
"by",
"id",
"attribute",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L293-L308
|
642 |
andybalholm/cascadia
|
parser.go
|
parseClassSelector
|
func (p *parser) parseClassSelector() (Selector, error) {
if p.i >= len(p.s) {
return nil, fmt.Errorf("expected class selector (.class), found EOF instead")
}
if p.s[p.i] != '.' {
return nil, fmt.Errorf("expected class selector (.class), found '%c' instead", p.s[p.i])
}
p.i++
class, err := p.parseIdentifier()
if err != nil {
return nil, err
}
return attributeIncludesSelector("class", class), nil
}
|
go
|
func (p *parser) parseClassSelector() (Selector, error) {
if p.i >= len(p.s) {
return nil, fmt.Errorf("expected class selector (.class), found EOF instead")
}
if p.s[p.i] != '.' {
return nil, fmt.Errorf("expected class selector (.class), found '%c' instead", p.s[p.i])
}
p.i++
class, err := p.parseIdentifier()
if err != nil {
return nil, err
}
return attributeIncludesSelector("class", class), nil
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseClassSelector",
"(",
")",
"(",
"Selector",
",",
"error",
")",
"{",
"if",
"p",
".",
"i",
">=",
"len",
"(",
"p",
".",
"s",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"!=",
"'.'",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
")",
"\n",
"}",
"\n\n",
"p",
".",
"i",
"++",
"\n",
"class",
",",
"err",
":=",
"p",
".",
"parseIdentifier",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"attributeIncludesSelector",
"(",
"\"",
"\"",
",",
"class",
")",
",",
"nil",
"\n",
"}"
] |
// parseClassSelector parses a selector that matches by class attribute.
|
[
"parseClassSelector",
"parses",
"a",
"selector",
"that",
"matches",
"by",
"class",
"attribute",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L311-L326
|
643 |
andybalholm/cascadia
|
parser.go
|
parseInteger
|
func (p *parser) parseInteger() (int, error) {
i := p.i
start := i
for i < len(p.s) && '0' <= p.s[i] && p.s[i] <= '9' {
i++
}
if i == start {
return 0, errors.New("expected integer, but didn't find it")
}
p.i = i
val, err := strconv.Atoi(p.s[start:i])
if err != nil {
return 0, err
}
return val, nil
}
|
go
|
func (p *parser) parseInteger() (int, error) {
i := p.i
start := i
for i < len(p.s) && '0' <= p.s[i] && p.s[i] <= '9' {
i++
}
if i == start {
return 0, errors.New("expected integer, but didn't find it")
}
p.i = i
val, err := strconv.Atoi(p.s[start:i])
if err != nil {
return 0, err
}
return val, nil
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseInteger",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"i",
":=",
"p",
".",
"i",
"\n",
"start",
":=",
"i",
"\n",
"for",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"&&",
"'0'",
"<=",
"p",
".",
"s",
"[",
"i",
"]",
"&&",
"p",
".",
"s",
"[",
"i",
"]",
"<=",
"'9'",
"{",
"i",
"++",
"\n",
"}",
"\n",
"if",
"i",
"==",
"start",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"p",
".",
"i",
"=",
"i",
"\n\n",
"val",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"p",
".",
"s",
"[",
"start",
":",
"i",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"val",
",",
"nil",
"\n",
"}"
] |
// parseInteger parses a decimal integer.
|
[
"parseInteger",
"parses",
"a",
"decimal",
"integer",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L566-L583
|
644 |
andybalholm/cascadia
|
parser.go
|
parseSimpleSelectorSequence
|
func (p *parser) parseSimpleSelectorSequence() (Selector, error) {
var result Selector
if p.i >= len(p.s) {
return nil, errors.New("expected selector, found EOF instead")
}
switch p.s[p.i] {
case '*':
// It's the universal selector. Just skip over it, since it doesn't affect the meaning.
p.i++
case '#', '.', '[', ':':
// There's no type selector. Wait to process the other till the main loop.
default:
r, err := p.parseTypeSelector()
if err != nil {
return nil, err
}
result = r
}
loop:
for p.i < len(p.s) {
var ns Selector
var err error
switch p.s[p.i] {
case '#':
ns, err = p.parseIDSelector()
case '.':
ns, err = p.parseClassSelector()
case '[':
ns, err = p.parseAttributeSelector()
case ':':
ns, err = p.parsePseudoclassSelector()
default:
break loop
}
if err != nil {
return nil, err
}
if result == nil {
result = ns
} else {
result = intersectionSelector(result, ns)
}
}
if result == nil {
result = func(n *html.Node) bool {
return n.Type == html.ElementNode
}
}
return result, nil
}
|
go
|
func (p *parser) parseSimpleSelectorSequence() (Selector, error) {
var result Selector
if p.i >= len(p.s) {
return nil, errors.New("expected selector, found EOF instead")
}
switch p.s[p.i] {
case '*':
// It's the universal selector. Just skip over it, since it doesn't affect the meaning.
p.i++
case '#', '.', '[', ':':
// There's no type selector. Wait to process the other till the main loop.
default:
r, err := p.parseTypeSelector()
if err != nil {
return nil, err
}
result = r
}
loop:
for p.i < len(p.s) {
var ns Selector
var err error
switch p.s[p.i] {
case '#':
ns, err = p.parseIDSelector()
case '.':
ns, err = p.parseClassSelector()
case '[':
ns, err = p.parseAttributeSelector()
case ':':
ns, err = p.parsePseudoclassSelector()
default:
break loop
}
if err != nil {
return nil, err
}
if result == nil {
result = ns
} else {
result = intersectionSelector(result, ns)
}
}
if result == nil {
result = func(n *html.Node) bool {
return n.Type == html.ElementNode
}
}
return result, nil
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseSimpleSelectorSequence",
"(",
")",
"(",
"Selector",
",",
"error",
")",
"{",
"var",
"result",
"Selector",
"\n\n",
"if",
"p",
".",
"i",
">=",
"len",
"(",
"p",
".",
"s",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"{",
"case",
"'*'",
":",
"// It's the universal selector. Just skip over it, since it doesn't affect the meaning.",
"p",
".",
"i",
"++",
"\n",
"case",
"'#'",
",",
"'.'",
",",
"'['",
",",
"':'",
":",
"// There's no type selector. Wait to process the other till the main loop.",
"default",
":",
"r",
",",
"err",
":=",
"p",
".",
"parseTypeSelector",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"result",
"=",
"r",
"\n",
"}",
"\n\n",
"loop",
":",
"for",
"p",
".",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"{",
"var",
"ns",
"Selector",
"\n",
"var",
"err",
"error",
"\n",
"switch",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"{",
"case",
"'#'",
":",
"ns",
",",
"err",
"=",
"p",
".",
"parseIDSelector",
"(",
")",
"\n",
"case",
"'.'",
":",
"ns",
",",
"err",
"=",
"p",
".",
"parseClassSelector",
"(",
")",
"\n",
"case",
"'['",
":",
"ns",
",",
"err",
"=",
"p",
".",
"parseAttributeSelector",
"(",
")",
"\n",
"case",
"':'",
":",
"ns",
",",
"err",
"=",
"p",
".",
"parsePseudoclassSelector",
"(",
")",
"\n",
"default",
":",
"break",
"loop",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"result",
"==",
"nil",
"{",
"result",
"=",
"ns",
"\n",
"}",
"else",
"{",
"result",
"=",
"intersectionSelector",
"(",
"result",
",",
"ns",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"result",
"==",
"nil",
"{",
"result",
"=",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"n",
".",
"Type",
"==",
"html",
".",
"ElementNode",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// parseSimpleSelectorSequence parses a selector sequence that applies to
// a single element.
|
[
"parseSimpleSelectorSequence",
"parses",
"a",
"selector",
"sequence",
"that",
"applies",
"to",
"a",
"single",
"element",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L708-L762
|
645 |
andybalholm/cascadia
|
parser.go
|
parseSelector
|
func (p *parser) parseSelector() (result Selector, err error) {
p.skipWhitespace()
result, err = p.parseSimpleSelectorSequence()
if err != nil {
return
}
for {
var combinator byte
if p.skipWhitespace() {
combinator = ' '
}
if p.i >= len(p.s) {
return
}
switch p.s[p.i] {
case '+', '>', '~':
combinator = p.s[p.i]
p.i++
p.skipWhitespace()
case ',', ')':
// These characters can't begin a selector, but they can legally occur after one.
return
}
if combinator == 0 {
return
}
c, err := p.parseSimpleSelectorSequence()
if err != nil {
return nil, err
}
switch combinator {
case ' ':
result = descendantSelector(result, c)
case '>':
result = childSelector(result, c)
case '+':
result = siblingSelector(result, c, true)
case '~':
result = siblingSelector(result, c, false)
}
}
panic("unreachable")
}
|
go
|
func (p *parser) parseSelector() (result Selector, err error) {
p.skipWhitespace()
result, err = p.parseSimpleSelectorSequence()
if err != nil {
return
}
for {
var combinator byte
if p.skipWhitespace() {
combinator = ' '
}
if p.i >= len(p.s) {
return
}
switch p.s[p.i] {
case '+', '>', '~':
combinator = p.s[p.i]
p.i++
p.skipWhitespace()
case ',', ')':
// These characters can't begin a selector, but they can legally occur after one.
return
}
if combinator == 0 {
return
}
c, err := p.parseSimpleSelectorSequence()
if err != nil {
return nil, err
}
switch combinator {
case ' ':
result = descendantSelector(result, c)
case '>':
result = childSelector(result, c)
case '+':
result = siblingSelector(result, c, true)
case '~':
result = siblingSelector(result, c, false)
}
}
panic("unreachable")
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseSelector",
"(",
")",
"(",
"result",
"Selector",
",",
"err",
"error",
")",
"{",
"p",
".",
"skipWhitespace",
"(",
")",
"\n",
"result",
",",
"err",
"=",
"p",
".",
"parseSimpleSelectorSequence",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"for",
"{",
"var",
"combinator",
"byte",
"\n",
"if",
"p",
".",
"skipWhitespace",
"(",
")",
"{",
"combinator",
"=",
"' '",
"\n",
"}",
"\n",
"if",
"p",
".",
"i",
">=",
"len",
"(",
"p",
".",
"s",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"switch",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"{",
"case",
"'+'",
",",
"'>'",
",",
"'~'",
":",
"combinator",
"=",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"\n",
"p",
".",
"i",
"++",
"\n",
"p",
".",
"skipWhitespace",
"(",
")",
"\n",
"case",
"','",
",",
"')'",
":",
"// These characters can't begin a selector, but they can legally occur after one.",
"return",
"\n",
"}",
"\n\n",
"if",
"combinator",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"c",
",",
"err",
":=",
"p",
".",
"parseSimpleSelectorSequence",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"combinator",
"{",
"case",
"' '",
":",
"result",
"=",
"descendantSelector",
"(",
"result",
",",
"c",
")",
"\n",
"case",
"'>'",
":",
"result",
"=",
"childSelector",
"(",
"result",
",",
"c",
")",
"\n",
"case",
"'+'",
":",
"result",
"=",
"siblingSelector",
"(",
"result",
",",
"c",
",",
"true",
")",
"\n",
"case",
"'~'",
":",
"result",
"=",
"siblingSelector",
"(",
"result",
",",
"c",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// parseSelector parses a selector that may include combinators.
|
[
"parseSelector",
"parses",
"a",
"selector",
"that",
"may",
"include",
"combinators",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L765-L813
|
646 |
andybalholm/cascadia
|
parser.go
|
parseSelectorGroup
|
func (p *parser) parseSelectorGroup() (result Selector, err error) {
result, err = p.parseSelector()
if err != nil {
return
}
for p.i < len(p.s) {
if p.s[p.i] != ',' {
return result, nil
}
p.i++
c, err := p.parseSelector()
if err != nil {
return nil, err
}
result = unionSelector(result, c)
}
return
}
|
go
|
func (p *parser) parseSelectorGroup() (result Selector, err error) {
result, err = p.parseSelector()
if err != nil {
return
}
for p.i < len(p.s) {
if p.s[p.i] != ',' {
return result, nil
}
p.i++
c, err := p.parseSelector()
if err != nil {
return nil, err
}
result = unionSelector(result, c)
}
return
}
|
[
"func",
"(",
"p",
"*",
"parser",
")",
"parseSelectorGroup",
"(",
")",
"(",
"result",
"Selector",
",",
"err",
"error",
")",
"{",
"result",
",",
"err",
"=",
"p",
".",
"parseSelector",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"for",
"p",
".",
"i",
"<",
"len",
"(",
"p",
".",
"s",
")",
"{",
"if",
"p",
".",
"s",
"[",
"p",
".",
"i",
"]",
"!=",
"','",
"{",
"return",
"result",
",",
"nil",
"\n",
"}",
"\n",
"p",
".",
"i",
"++",
"\n",
"c",
",",
"err",
":=",
"p",
".",
"parseSelector",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"result",
"=",
"unionSelector",
"(",
"result",
",",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// parseSelectorGroup parses a group of selectors, separated by commas.
|
[
"parseSelectorGroup",
"parses",
"a",
"group",
"of",
"selectors",
"separated",
"by",
"commas",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/parser.go#L816-L835
|
647 |
andybalholm/cascadia
|
fuzz/fuzz.go
|
Fuzz
|
func Fuzz(data []byte) int {
sel, err := cascadia.Compile(string(data))
if err != nil {
if sel != nil {
panic("sel != nil on error")
}
return 0
}
return 1
}
|
go
|
func Fuzz(data []byte) int {
sel, err := cascadia.Compile(string(data))
if err != nil {
if sel != nil {
panic("sel != nil on error")
}
return 0
}
return 1
}
|
[
"func",
"Fuzz",
"(",
"data",
"[",
"]",
"byte",
")",
"int",
"{",
"sel",
",",
"err",
":=",
"cascadia",
".",
"Compile",
"(",
"string",
"(",
"data",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"sel",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"}",
"\n",
"return",
"1",
"\n",
"}"
] |
// Fuzz is the entrypoint used by the go-fuzz framework
|
[
"Fuzz",
"is",
"the",
"entrypoint",
"used",
"by",
"the",
"go",
"-",
"fuzz",
"framework"
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/fuzz/fuzz.go#L6-L15
|
648 |
andybalholm/cascadia
|
selector.go
|
hasChildMatch
|
func hasChildMatch(n *html.Node, a Selector) bool {
for c := n.FirstChild; c != nil; c = c.NextSibling {
if a(c) {
return true
}
}
return false
}
|
go
|
func hasChildMatch(n *html.Node, a Selector) bool {
for c := n.FirstChild; c != nil; c = c.NextSibling {
if a(c) {
return true
}
}
return false
}
|
[
"func",
"hasChildMatch",
"(",
"n",
"*",
"html",
".",
"Node",
",",
"a",
"Selector",
")",
"bool",
"{",
"for",
"c",
":=",
"n",
".",
"FirstChild",
";",
"c",
"!=",
"nil",
";",
"c",
"=",
"c",
".",
"NextSibling",
"{",
"if",
"a",
"(",
"c",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// hasChildMatch returns whether n has any child that matches a.
|
[
"hasChildMatch",
"returns",
"whether",
"n",
"has",
"any",
"child",
"that",
"matches",
"a",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L18-L25
|
649 |
andybalholm/cascadia
|
selector.go
|
hasDescendantMatch
|
func hasDescendantMatch(n *html.Node, a Selector) bool {
for c := n.FirstChild; c != nil; c = c.NextSibling {
if a(c) || (c.Type == html.ElementNode && hasDescendantMatch(c, a)) {
return true
}
}
return false
}
|
go
|
func hasDescendantMatch(n *html.Node, a Selector) bool {
for c := n.FirstChild; c != nil; c = c.NextSibling {
if a(c) || (c.Type == html.ElementNode && hasDescendantMatch(c, a)) {
return true
}
}
return false
}
|
[
"func",
"hasDescendantMatch",
"(",
"n",
"*",
"html",
".",
"Node",
",",
"a",
"Selector",
")",
"bool",
"{",
"for",
"c",
":=",
"n",
".",
"FirstChild",
";",
"c",
"!=",
"nil",
";",
"c",
"=",
"c",
".",
"NextSibling",
"{",
"if",
"a",
"(",
"c",
")",
"||",
"(",
"c",
".",
"Type",
"==",
"html",
".",
"ElementNode",
"&&",
"hasDescendantMatch",
"(",
"c",
",",
"a",
")",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// hasDescendantMatch performs a depth-first search of n's descendants,
// testing whether any of them match a. It returns true as soon as a match is
// found, or false if no match is found.
|
[
"hasDescendantMatch",
"performs",
"a",
"depth",
"-",
"first",
"search",
"of",
"n",
"s",
"descendants",
"testing",
"whether",
"any",
"of",
"them",
"match",
"a",
".",
"It",
"returns",
"true",
"as",
"soon",
"as",
"a",
"match",
"is",
"found",
"or",
"false",
"if",
"no",
"match",
"is",
"found",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L30-L37
|
650 |
andybalholm/cascadia
|
selector.go
|
Compile
|
func Compile(sel string) (Selector, error) {
p := &parser{s: sel}
compiled, err := p.parseSelectorGroup()
if err != nil {
return nil, err
}
if p.i < len(sel) {
return nil, fmt.Errorf("parsing %q: %d bytes left over", sel, len(sel)-p.i)
}
return compiled, nil
}
|
go
|
func Compile(sel string) (Selector, error) {
p := &parser{s: sel}
compiled, err := p.parseSelectorGroup()
if err != nil {
return nil, err
}
if p.i < len(sel) {
return nil, fmt.Errorf("parsing %q: %d bytes left over", sel, len(sel)-p.i)
}
return compiled, nil
}
|
[
"func",
"Compile",
"(",
"sel",
"string",
")",
"(",
"Selector",
",",
"error",
")",
"{",
"p",
":=",
"&",
"parser",
"{",
"s",
":",
"sel",
"}",
"\n",
"compiled",
",",
"err",
":=",
"p",
".",
"parseSelectorGroup",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"p",
".",
"i",
"<",
"len",
"(",
"sel",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sel",
",",
"len",
"(",
"sel",
")",
"-",
"p",
".",
"i",
")",
"\n",
"}",
"\n\n",
"return",
"compiled",
",",
"nil",
"\n",
"}"
] |
// Compile parses a selector and returns, if successful, a Selector object
// that can be used to match against html.Node objects.
|
[
"Compile",
"parses",
"a",
"selector",
"and",
"returns",
"if",
"successful",
"a",
"Selector",
"object",
"that",
"can",
"be",
"used",
"to",
"match",
"against",
"html",
".",
"Node",
"objects",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L41-L53
|
651 |
andybalholm/cascadia
|
selector.go
|
MustCompile
|
func MustCompile(sel string) Selector {
compiled, err := Compile(sel)
if err != nil {
panic(err)
}
return compiled
}
|
go
|
func MustCompile(sel string) Selector {
compiled, err := Compile(sel)
if err != nil {
panic(err)
}
return compiled
}
|
[
"func",
"MustCompile",
"(",
"sel",
"string",
")",
"Selector",
"{",
"compiled",
",",
"err",
":=",
"Compile",
"(",
"sel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"compiled",
"\n",
"}"
] |
// MustCompile is like Compile, but panics instead of returning an error.
|
[
"MustCompile",
"is",
"like",
"Compile",
"but",
"panics",
"instead",
"of",
"returning",
"an",
"error",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L56-L62
|
652 |
andybalholm/cascadia
|
selector.go
|
MatchAll
|
func (s Selector) MatchAll(n *html.Node) []*html.Node {
return s.matchAllInto(n, nil)
}
|
go
|
func (s Selector) MatchAll(n *html.Node) []*html.Node {
return s.matchAllInto(n, nil)
}
|
[
"func",
"(",
"s",
"Selector",
")",
"MatchAll",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"[",
"]",
"*",
"html",
".",
"Node",
"{",
"return",
"s",
".",
"matchAllInto",
"(",
"n",
",",
"nil",
")",
"\n",
"}"
] |
// MatchAll returns a slice of the nodes that match the selector,
// from n and its children.
|
[
"MatchAll",
"returns",
"a",
"slice",
"of",
"the",
"nodes",
"that",
"match",
"the",
"selector",
"from",
"n",
"and",
"its",
"children",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L66-L68
|
653 |
andybalholm/cascadia
|
selector.go
|
MatchFirst
|
func (s Selector) MatchFirst(n *html.Node) *html.Node {
if s.Match(n) {
return n
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
m := s.MatchFirst(c)
if m != nil {
return m
}
}
return nil
}
|
go
|
func (s Selector) MatchFirst(n *html.Node) *html.Node {
if s.Match(n) {
return n
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
m := s.MatchFirst(c)
if m != nil {
return m
}
}
return nil
}
|
[
"func",
"(",
"s",
"Selector",
")",
"MatchFirst",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"*",
"html",
".",
"Node",
"{",
"if",
"s",
".",
"Match",
"(",
"n",
")",
"{",
"return",
"n",
"\n",
"}",
"\n\n",
"for",
"c",
":=",
"n",
".",
"FirstChild",
";",
"c",
"!=",
"nil",
";",
"c",
"=",
"c",
".",
"NextSibling",
"{",
"m",
":=",
"s",
".",
"MatchFirst",
"(",
"c",
")",
"\n",
"if",
"m",
"!=",
"nil",
"{",
"return",
"m",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// MatchFirst returns the first node that matches s, from n and its children.
|
[
"MatchFirst",
"returns",
"the",
"first",
"node",
"that",
"matches",
"s",
"from",
"n",
"and",
"its",
"children",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L88-L100
|
654 |
andybalholm/cascadia
|
selector.go
|
Filter
|
func (s Selector) Filter(nodes []*html.Node) (result []*html.Node) {
for _, n := range nodes {
if s(n) {
result = append(result, n)
}
}
return result
}
|
go
|
func (s Selector) Filter(nodes []*html.Node) (result []*html.Node) {
for _, n := range nodes {
if s(n) {
result = append(result, n)
}
}
return result
}
|
[
"func",
"(",
"s",
"Selector",
")",
"Filter",
"(",
"nodes",
"[",
"]",
"*",
"html",
".",
"Node",
")",
"(",
"result",
"[",
"]",
"*",
"html",
".",
"Node",
")",
"{",
"for",
"_",
",",
"n",
":=",
"range",
"nodes",
"{",
"if",
"s",
"(",
"n",
")",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"n",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// Filter returns the nodes in nodes that match the selector.
|
[
"Filter",
"returns",
"the",
"nodes",
"in",
"nodes",
"that",
"match",
"the",
"selector",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L103-L110
|
655 |
andybalholm/cascadia
|
selector.go
|
typeSelector
|
func typeSelector(tag string) Selector {
tag = toLowerASCII(tag)
return func(n *html.Node) bool {
return n.Type == html.ElementNode && n.Data == tag
}
}
|
go
|
func typeSelector(tag string) Selector {
tag = toLowerASCII(tag)
return func(n *html.Node) bool {
return n.Type == html.ElementNode && n.Data == tag
}
}
|
[
"func",
"typeSelector",
"(",
"tag",
"string",
")",
"Selector",
"{",
"tag",
"=",
"toLowerASCII",
"(",
"tag",
")",
"\n",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"n",
".",
"Type",
"==",
"html",
".",
"ElementNode",
"&&",
"n",
".",
"Data",
"==",
"tag",
"\n",
"}",
"\n",
"}"
] |
// typeSelector returns a Selector that matches elements with a given tag name.
|
[
"typeSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"elements",
"with",
"a",
"given",
"tag",
"name",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L113-L118
|
656 |
andybalholm/cascadia
|
selector.go
|
toLowerASCII
|
func toLowerASCII(s string) string {
var b []byte
for i := 0; i < len(s); i++ {
if c := s[i]; 'A' <= c && c <= 'Z' {
if b == nil {
b = make([]byte, len(s))
copy(b, s)
}
b[i] = s[i] + ('a' - 'A')
}
}
if b == nil {
return s
}
return string(b)
}
|
go
|
func toLowerASCII(s string) string {
var b []byte
for i := 0; i < len(s); i++ {
if c := s[i]; 'A' <= c && c <= 'Z' {
if b == nil {
b = make([]byte, len(s))
copy(b, s)
}
b[i] = s[i] + ('a' - 'A')
}
}
if b == nil {
return s
}
return string(b)
}
|
[
"func",
"toLowerASCII",
"(",
"s",
"string",
")",
"string",
"{",
"var",
"b",
"[",
"]",
"byte",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"s",
")",
";",
"i",
"++",
"{",
"if",
"c",
":=",
"s",
"[",
"i",
"]",
";",
"'A'",
"<=",
"c",
"&&",
"c",
"<=",
"'Z'",
"{",
"if",
"b",
"==",
"nil",
"{",
"b",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"s",
")",
")",
"\n",
"copy",
"(",
"b",
",",
"s",
")",
"\n",
"}",
"\n",
"b",
"[",
"i",
"]",
"=",
"s",
"[",
"i",
"]",
"+",
"(",
"'a'",
"-",
"'A'",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"b",
"==",
"nil",
"{",
"return",
"s",
"\n",
"}",
"\n\n",
"return",
"string",
"(",
"b",
")",
"\n",
"}"
] |
// toLowerASCII returns s with all ASCII capital letters lowercased.
|
[
"toLowerASCII",
"returns",
"s",
"with",
"all",
"ASCII",
"capital",
"letters",
"lowercased",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L121-L138
|
657 |
andybalholm/cascadia
|
selector.go
|
attributeEqualsSelector
|
func attributeEqualsSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
return s == val
})
}
|
go
|
func attributeEqualsSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
return s == val
})
}
|
[
"func",
"attributeEqualsSelector",
"(",
"key",
",",
"val",
"string",
")",
"Selector",
"{",
"return",
"attributeSelector",
"(",
"key",
",",
"func",
"(",
"s",
"string",
")",
"bool",
"{",
"return",
"s",
"==",
"val",
"\n",
"}",
")",
"\n",
"}"
] |
// attributeEqualsSelector returns a Selector that matches elements where
// the attribute named key has the value val.
|
[
"attributeEqualsSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"elements",
"where",
"the",
"attribute",
"named",
"key",
"has",
"the",
"value",
"val",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L165-L170
|
658 |
andybalholm/cascadia
|
selector.go
|
attributeNotEqualSelector
|
func attributeNotEqualSelector(key, val string) Selector {
key = toLowerASCII(key)
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
for _, a := range n.Attr {
if a.Key == key && a.Val == val {
return false
}
}
return true
}
}
|
go
|
func attributeNotEqualSelector(key, val string) Selector {
key = toLowerASCII(key)
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
for _, a := range n.Attr {
if a.Key == key && a.Val == val {
return false
}
}
return true
}
}
|
[
"func",
"attributeNotEqualSelector",
"(",
"key",
",",
"val",
"string",
")",
"Selector",
"{",
"key",
"=",
"toLowerASCII",
"(",
"key",
")",
"\n",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"if",
"n",
".",
"Type",
"!=",
"html",
".",
"ElementNode",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"n",
".",
"Attr",
"{",
"if",
"a",
".",
"Key",
"==",
"key",
"&&",
"a",
".",
"Val",
"==",
"val",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}"
] |
// attributeNotEqualSelector returns a Selector that matches elements where
// the attribute named key does not have the value val.
|
[
"attributeNotEqualSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"elements",
"where",
"the",
"attribute",
"named",
"key",
"does",
"not",
"have",
"the",
"value",
"val",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L174-L187
|
659 |
andybalholm/cascadia
|
selector.go
|
attributeIncludesSelector
|
func attributeIncludesSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
for s != "" {
i := strings.IndexAny(s, " \t\r\n\f")
if i == -1 {
return s == val
}
if s[:i] == val {
return true
}
s = s[i+1:]
}
return false
})
}
|
go
|
func attributeIncludesSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
for s != "" {
i := strings.IndexAny(s, " \t\r\n\f")
if i == -1 {
return s == val
}
if s[:i] == val {
return true
}
s = s[i+1:]
}
return false
})
}
|
[
"func",
"attributeIncludesSelector",
"(",
"key",
",",
"val",
"string",
")",
"Selector",
"{",
"return",
"attributeSelector",
"(",
"key",
",",
"func",
"(",
"s",
"string",
")",
"bool",
"{",
"for",
"s",
"!=",
"\"",
"\"",
"{",
"i",
":=",
"strings",
".",
"IndexAny",
"(",
"s",
",",
"\"",
"\\t",
"\\r",
"\\n",
"\\f",
"\"",
")",
"\n",
"if",
"i",
"==",
"-",
"1",
"{",
"return",
"s",
"==",
"val",
"\n",
"}",
"\n",
"if",
"s",
"[",
":",
"i",
"]",
"==",
"val",
"{",
"return",
"true",
"\n",
"}",
"\n",
"s",
"=",
"s",
"[",
"i",
"+",
"1",
":",
"]",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
")",
"\n",
"}"
] |
// attributeIncludesSelector returns a Selector that matches elements where
// the attribute named key is a whitespace-separated list that includes val.
|
[
"attributeIncludesSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"elements",
"where",
"the",
"attribute",
"named",
"key",
"is",
"a",
"whitespace",
"-",
"separated",
"list",
"that",
"includes",
"val",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L191-L206
|
660 |
andybalholm/cascadia
|
selector.go
|
attributeDashmatchSelector
|
func attributeDashmatchSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if s == val {
return true
}
if len(s) <= len(val) {
return false
}
if s[:len(val)] == val && s[len(val)] == '-' {
return true
}
return false
})
}
|
go
|
func attributeDashmatchSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if s == val {
return true
}
if len(s) <= len(val) {
return false
}
if s[:len(val)] == val && s[len(val)] == '-' {
return true
}
return false
})
}
|
[
"func",
"attributeDashmatchSelector",
"(",
"key",
",",
"val",
"string",
")",
"Selector",
"{",
"return",
"attributeSelector",
"(",
"key",
",",
"func",
"(",
"s",
"string",
")",
"bool",
"{",
"if",
"s",
"==",
"val",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"len",
"(",
"s",
")",
"<=",
"len",
"(",
"val",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"s",
"[",
":",
"len",
"(",
"val",
")",
"]",
"==",
"val",
"&&",
"s",
"[",
"len",
"(",
"val",
")",
"]",
"==",
"'-'",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
")",
"\n",
"}"
] |
// attributeDashmatchSelector returns a Selector that matches elements where
// the attribute named key equals val or starts with val plus a hyphen.
|
[
"attributeDashmatchSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"elements",
"where",
"the",
"attribute",
"named",
"key",
"equals",
"val",
"or",
"starts",
"with",
"val",
"plus",
"a",
"hyphen",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L210-L224
|
661 |
andybalholm/cascadia
|
selector.go
|
attributePrefixSelector
|
func attributePrefixSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
return strings.HasPrefix(s, val)
})
}
|
go
|
func attributePrefixSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
return strings.HasPrefix(s, val)
})
}
|
[
"func",
"attributePrefixSelector",
"(",
"key",
",",
"val",
"string",
")",
"Selector",
"{",
"return",
"attributeSelector",
"(",
"key",
",",
"func",
"(",
"s",
"string",
")",
"bool",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"strings",
".",
"HasPrefix",
"(",
"s",
",",
"val",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// attributePrefixSelector returns a Selector that matches elements where
// the attribute named key starts with val.
|
[
"attributePrefixSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"elements",
"where",
"the",
"attribute",
"named",
"key",
"starts",
"with",
"val",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L228-L236
|
662 |
andybalholm/cascadia
|
selector.go
|
attributeSuffixSelector
|
func attributeSuffixSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
return strings.HasSuffix(s, val)
})
}
|
go
|
func attributeSuffixSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
return strings.HasSuffix(s, val)
})
}
|
[
"func",
"attributeSuffixSelector",
"(",
"key",
",",
"val",
"string",
")",
"Selector",
"{",
"return",
"attributeSelector",
"(",
"key",
",",
"func",
"(",
"s",
"string",
")",
"bool",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"strings",
".",
"HasSuffix",
"(",
"s",
",",
"val",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// attributeSuffixSelector returns a Selector that matches elements where
// the attribute named key ends with val.
|
[
"attributeSuffixSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"elements",
"where",
"the",
"attribute",
"named",
"key",
"ends",
"with",
"val",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L240-L248
|
663 |
andybalholm/cascadia
|
selector.go
|
attributeSubstringSelector
|
func attributeSubstringSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
return strings.Contains(s, val)
})
}
|
go
|
func attributeSubstringSelector(key, val string) Selector {
return attributeSelector(key,
func(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
return strings.Contains(s, val)
})
}
|
[
"func",
"attributeSubstringSelector",
"(",
"key",
",",
"val",
"string",
")",
"Selector",
"{",
"return",
"attributeSelector",
"(",
"key",
",",
"func",
"(",
"s",
"string",
")",
"bool",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"s",
")",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"s",
",",
"val",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// attributeSubstringSelector returns a Selector that matches nodes where
// the attribute named key contains val.
|
[
"attributeSubstringSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"nodes",
"where",
"the",
"attribute",
"named",
"key",
"contains",
"val",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L252-L260
|
664 |
andybalholm/cascadia
|
selector.go
|
attributeRegexSelector
|
func attributeRegexSelector(key string, rx *regexp.Regexp) Selector {
return attributeSelector(key,
func(s string) bool {
return rx.MatchString(s)
})
}
|
go
|
func attributeRegexSelector(key string, rx *regexp.Regexp) Selector {
return attributeSelector(key,
func(s string) bool {
return rx.MatchString(s)
})
}
|
[
"func",
"attributeRegexSelector",
"(",
"key",
"string",
",",
"rx",
"*",
"regexp",
".",
"Regexp",
")",
"Selector",
"{",
"return",
"attributeSelector",
"(",
"key",
",",
"func",
"(",
"s",
"string",
")",
"bool",
"{",
"return",
"rx",
".",
"MatchString",
"(",
"s",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// attributeRegexSelector returns a Selector that matches nodes where
// the attribute named key matches the regular expression rx
|
[
"attributeRegexSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"nodes",
"where",
"the",
"attribute",
"named",
"key",
"matches",
"the",
"regular",
"expression",
"rx"
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L264-L269
|
665 |
andybalholm/cascadia
|
selector.go
|
intersectionSelector
|
func intersectionSelector(a, b Selector) Selector {
return func(n *html.Node) bool {
return a(n) && b(n)
}
}
|
go
|
func intersectionSelector(a, b Selector) Selector {
return func(n *html.Node) bool {
return a(n) && b(n)
}
}
|
[
"func",
"intersectionSelector",
"(",
"a",
",",
"b",
"Selector",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"a",
"(",
"n",
")",
"&&",
"b",
"(",
"n",
")",
"\n",
"}",
"\n",
"}"
] |
// intersectionSelector returns a selector that matches nodes that match
// both a and b.
|
[
"intersectionSelector",
"returns",
"a",
"selector",
"that",
"matches",
"nodes",
"that",
"match",
"both",
"a",
"and",
"b",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L273-L277
|
666 |
andybalholm/cascadia
|
selector.go
|
unionSelector
|
func unionSelector(a, b Selector) Selector {
return func(n *html.Node) bool {
return a(n) || b(n)
}
}
|
go
|
func unionSelector(a, b Selector) Selector {
return func(n *html.Node) bool {
return a(n) || b(n)
}
}
|
[
"func",
"unionSelector",
"(",
"a",
",",
"b",
"Selector",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"a",
"(",
"n",
")",
"||",
"b",
"(",
"n",
")",
"\n",
"}",
"\n",
"}"
] |
// unionSelector returns a selector that matches elements that match
// either a or b.
|
[
"unionSelector",
"returns",
"a",
"selector",
"that",
"matches",
"elements",
"that",
"match",
"either",
"a",
"or",
"b",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L281-L285
|
667 |
andybalholm/cascadia
|
selector.go
|
negatedSelector
|
func negatedSelector(a Selector) Selector {
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
return !a(n)
}
}
|
go
|
func negatedSelector(a Selector) Selector {
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
return !a(n)
}
}
|
[
"func",
"negatedSelector",
"(",
"a",
"Selector",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"if",
"n",
".",
"Type",
"!=",
"html",
".",
"ElementNode",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"!",
"a",
"(",
"n",
")",
"\n",
"}",
"\n",
"}"
] |
// negatedSelector returns a selector that matches elements that do not match a.
|
[
"negatedSelector",
"returns",
"a",
"selector",
"that",
"matches",
"elements",
"that",
"do",
"not",
"match",
"a",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L288-L295
|
668 |
andybalholm/cascadia
|
selector.go
|
writeNodeText
|
func writeNodeText(n *html.Node, b *bytes.Buffer) {
switch n.Type {
case html.TextNode:
b.WriteString(n.Data)
case html.ElementNode:
for c := n.FirstChild; c != nil; c = c.NextSibling {
writeNodeText(c, b)
}
}
}
|
go
|
func writeNodeText(n *html.Node, b *bytes.Buffer) {
switch n.Type {
case html.TextNode:
b.WriteString(n.Data)
case html.ElementNode:
for c := n.FirstChild; c != nil; c = c.NextSibling {
writeNodeText(c, b)
}
}
}
|
[
"func",
"writeNodeText",
"(",
"n",
"*",
"html",
".",
"Node",
",",
"b",
"*",
"bytes",
".",
"Buffer",
")",
"{",
"switch",
"n",
".",
"Type",
"{",
"case",
"html",
".",
"TextNode",
":",
"b",
".",
"WriteString",
"(",
"n",
".",
"Data",
")",
"\n",
"case",
"html",
".",
"ElementNode",
":",
"for",
"c",
":=",
"n",
".",
"FirstChild",
";",
"c",
"!=",
"nil",
";",
"c",
"=",
"c",
".",
"NextSibling",
"{",
"writeNodeText",
"(",
"c",
",",
"b",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// writeNodeText writes the text contained in n and its descendants to b.
|
[
"writeNodeText",
"writes",
"the",
"text",
"contained",
"in",
"n",
"and",
"its",
"descendants",
"to",
"b",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L298-L307
|
669 |
andybalholm/cascadia
|
selector.go
|
nodeText
|
func nodeText(n *html.Node) string {
var b bytes.Buffer
writeNodeText(n, &b)
return b.String()
}
|
go
|
func nodeText(n *html.Node) string {
var b bytes.Buffer
writeNodeText(n, &b)
return b.String()
}
|
[
"func",
"nodeText",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"string",
"{",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"writeNodeText",
"(",
"n",
",",
"&",
"b",
")",
"\n",
"return",
"b",
".",
"String",
"(",
")",
"\n",
"}"
] |
// nodeText returns the text contained in n and its descendants.
|
[
"nodeText",
"returns",
"the",
"text",
"contained",
"in",
"n",
"and",
"its",
"descendants",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L310-L314
|
670 |
andybalholm/cascadia
|
selector.go
|
nodeOwnText
|
func nodeOwnText(n *html.Node) string {
var b bytes.Buffer
for c := n.FirstChild; c != nil; c = c.NextSibling {
if c.Type == html.TextNode {
b.WriteString(c.Data)
}
}
return b.String()
}
|
go
|
func nodeOwnText(n *html.Node) string {
var b bytes.Buffer
for c := n.FirstChild; c != nil; c = c.NextSibling {
if c.Type == html.TextNode {
b.WriteString(c.Data)
}
}
return b.String()
}
|
[
"func",
"nodeOwnText",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"string",
"{",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"for",
"c",
":=",
"n",
".",
"FirstChild",
";",
"c",
"!=",
"nil",
";",
"c",
"=",
"c",
".",
"NextSibling",
"{",
"if",
"c",
".",
"Type",
"==",
"html",
".",
"TextNode",
"{",
"b",
".",
"WriteString",
"(",
"c",
".",
"Data",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"b",
".",
"String",
"(",
")",
"\n",
"}"
] |
// nodeOwnText returns the contents of the text nodes that are direct
// children of n.
|
[
"nodeOwnText",
"returns",
"the",
"contents",
"of",
"the",
"text",
"nodes",
"that",
"are",
"direct",
"children",
"of",
"n",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L318-L326
|
671 |
andybalholm/cascadia
|
selector.go
|
textSubstrSelector
|
func textSubstrSelector(val string) Selector {
return func(n *html.Node) bool {
text := strings.ToLower(nodeText(n))
return strings.Contains(text, val)
}
}
|
go
|
func textSubstrSelector(val string) Selector {
return func(n *html.Node) bool {
text := strings.ToLower(nodeText(n))
return strings.Contains(text, val)
}
}
|
[
"func",
"textSubstrSelector",
"(",
"val",
"string",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"text",
":=",
"strings",
".",
"ToLower",
"(",
"nodeText",
"(",
"n",
")",
")",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"text",
",",
"val",
")",
"\n",
"}",
"\n",
"}"
] |
// textSubstrSelector returns a selector that matches nodes that
// contain the given text.
|
[
"textSubstrSelector",
"returns",
"a",
"selector",
"that",
"matches",
"nodes",
"that",
"contain",
"the",
"given",
"text",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L330-L335
|
672 |
andybalholm/cascadia
|
selector.go
|
ownTextSubstrSelector
|
func ownTextSubstrSelector(val string) Selector {
return func(n *html.Node) bool {
text := strings.ToLower(nodeOwnText(n))
return strings.Contains(text, val)
}
}
|
go
|
func ownTextSubstrSelector(val string) Selector {
return func(n *html.Node) bool {
text := strings.ToLower(nodeOwnText(n))
return strings.Contains(text, val)
}
}
|
[
"func",
"ownTextSubstrSelector",
"(",
"val",
"string",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"text",
":=",
"strings",
".",
"ToLower",
"(",
"nodeOwnText",
"(",
"n",
")",
")",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"text",
",",
"val",
")",
"\n",
"}",
"\n",
"}"
] |
// ownTextSubstrSelector returns a selector that matches nodes that
// directly contain the given text
|
[
"ownTextSubstrSelector",
"returns",
"a",
"selector",
"that",
"matches",
"nodes",
"that",
"directly",
"contain",
"the",
"given",
"text"
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L339-L344
|
673 |
andybalholm/cascadia
|
selector.go
|
textRegexSelector
|
func textRegexSelector(rx *regexp.Regexp) Selector {
return func(n *html.Node) bool {
return rx.MatchString(nodeText(n))
}
}
|
go
|
func textRegexSelector(rx *regexp.Regexp) Selector {
return func(n *html.Node) bool {
return rx.MatchString(nodeText(n))
}
}
|
[
"func",
"textRegexSelector",
"(",
"rx",
"*",
"regexp",
".",
"Regexp",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"rx",
".",
"MatchString",
"(",
"nodeText",
"(",
"n",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// textRegexSelector returns a selector that matches nodes whose text matches
// the specified regular expression
|
[
"textRegexSelector",
"returns",
"a",
"selector",
"that",
"matches",
"nodes",
"whose",
"text",
"matches",
"the",
"specified",
"regular",
"expression"
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L348-L352
|
674 |
andybalholm/cascadia
|
selector.go
|
ownTextRegexSelector
|
func ownTextRegexSelector(rx *regexp.Regexp) Selector {
return func(n *html.Node) bool {
return rx.MatchString(nodeOwnText(n))
}
}
|
go
|
func ownTextRegexSelector(rx *regexp.Regexp) Selector {
return func(n *html.Node) bool {
return rx.MatchString(nodeOwnText(n))
}
}
|
[
"func",
"ownTextRegexSelector",
"(",
"rx",
"*",
"regexp",
".",
"Regexp",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"rx",
".",
"MatchString",
"(",
"nodeOwnText",
"(",
"n",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// ownTextRegexSelector returns a selector that matches nodes whose text
// directly matches the specified regular expression
|
[
"ownTextRegexSelector",
"returns",
"a",
"selector",
"that",
"matches",
"nodes",
"whose",
"text",
"directly",
"matches",
"the",
"specified",
"regular",
"expression"
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L356-L360
|
675 |
andybalholm/cascadia
|
selector.go
|
hasChildSelector
|
func hasChildSelector(a Selector) Selector {
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
return hasChildMatch(n, a)
}
}
|
go
|
func hasChildSelector(a Selector) Selector {
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
return hasChildMatch(n, a)
}
}
|
[
"func",
"hasChildSelector",
"(",
"a",
"Selector",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"if",
"n",
".",
"Type",
"!=",
"html",
".",
"ElementNode",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"hasChildMatch",
"(",
"n",
",",
"a",
")",
"\n",
"}",
"\n",
"}"
] |
// hasChildSelector returns a selector that matches elements
// with a child that matches a.
|
[
"hasChildSelector",
"returns",
"a",
"selector",
"that",
"matches",
"elements",
"with",
"a",
"child",
"that",
"matches",
"a",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L364-L371
|
676 |
andybalholm/cascadia
|
selector.go
|
hasDescendantSelector
|
func hasDescendantSelector(a Selector) Selector {
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
return hasDescendantMatch(n, a)
}
}
|
go
|
func hasDescendantSelector(a Selector) Selector {
return func(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
return hasDescendantMatch(n, a)
}
}
|
[
"func",
"hasDescendantSelector",
"(",
"a",
"Selector",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"if",
"n",
".",
"Type",
"!=",
"html",
".",
"ElementNode",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"hasDescendantMatch",
"(",
"n",
",",
"a",
")",
"\n",
"}",
"\n",
"}"
] |
// hasDescendantSelector returns a selector that matches elements
// with any descendant that matches a.
|
[
"hasDescendantSelector",
"returns",
"a",
"selector",
"that",
"matches",
"elements",
"with",
"any",
"descendant",
"that",
"matches",
"a",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L375-L382
|
677 |
andybalholm/cascadia
|
selector.go
|
inputSelector
|
func inputSelector(n *html.Node) bool {
return n.Type == html.ElementNode && (n.Data == "input" || n.Data == "select" || n.Data == "textarea" || n.Data == "button")
}
|
go
|
func inputSelector(n *html.Node) bool {
return n.Type == html.ElementNode && (n.Data == "input" || n.Data == "select" || n.Data == "textarea" || n.Data == "button")
}
|
[
"func",
"inputSelector",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"n",
".",
"Type",
"==",
"html",
".",
"ElementNode",
"&&",
"(",
"n",
".",
"Data",
"==",
"\"",
"\"",
"||",
"n",
".",
"Data",
"==",
"\"",
"\"",
"||",
"n",
".",
"Data",
"==",
"\"",
"\"",
"||",
"n",
".",
"Data",
"==",
"\"",
"\"",
")",
"\n",
"}"
] |
// inputSelector is a Selector that matches input, select, textarea and button elements.
|
[
"inputSelector",
"is",
"a",
"Selector",
"that",
"matches",
"input",
"select",
"textarea",
"and",
"button",
"elements",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L537-L539
|
678 |
andybalholm/cascadia
|
selector.go
|
emptyElementSelector
|
func emptyElementSelector(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
switch c.Type {
case html.ElementNode, html.TextNode:
return false
}
}
return true
}
|
go
|
func emptyElementSelector(n *html.Node) bool {
if n.Type != html.ElementNode {
return false
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
switch c.Type {
case html.ElementNode, html.TextNode:
return false
}
}
return true
}
|
[
"func",
"emptyElementSelector",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"if",
"n",
".",
"Type",
"!=",
"html",
".",
"ElementNode",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"c",
":=",
"n",
".",
"FirstChild",
";",
"c",
"!=",
"nil",
";",
"c",
"=",
"c",
".",
"NextSibling",
"{",
"switch",
"c",
".",
"Type",
"{",
"case",
"html",
".",
"ElementNode",
",",
"html",
".",
"TextNode",
":",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// emptyElementSelector is a Selector that matches empty elements.
|
[
"emptyElementSelector",
"is",
"a",
"Selector",
"that",
"matches",
"empty",
"elements",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L542-L555
|
679 |
andybalholm/cascadia
|
selector.go
|
descendantSelector
|
func descendantSelector(a, d Selector) Selector {
return func(n *html.Node) bool {
if !d(n) {
return false
}
for p := n.Parent; p != nil; p = p.Parent {
if a(p) {
return true
}
}
return false
}
}
|
go
|
func descendantSelector(a, d Selector) Selector {
return func(n *html.Node) bool {
if !d(n) {
return false
}
for p := n.Parent; p != nil; p = p.Parent {
if a(p) {
return true
}
}
return false
}
}
|
[
"func",
"descendantSelector",
"(",
"a",
",",
"d",
"Selector",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"if",
"!",
"d",
"(",
"n",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"p",
":=",
"n",
".",
"Parent",
";",
"p",
"!=",
"nil",
";",
"p",
"=",
"p",
".",
"Parent",
"{",
"if",
"a",
"(",
"p",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}",
"\n",
"}"
] |
// descendantSelector returns a Selector that matches an element if
// it matches d and has an ancestor that matches a.
|
[
"descendantSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"an",
"element",
"if",
"it",
"matches",
"d",
"and",
"has",
"an",
"ancestor",
"that",
"matches",
"a",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L559-L573
|
680 |
andybalholm/cascadia
|
selector.go
|
childSelector
|
func childSelector(a, d Selector) Selector {
return func(n *html.Node) bool {
return d(n) && n.Parent != nil && a(n.Parent)
}
}
|
go
|
func childSelector(a, d Selector) Selector {
return func(n *html.Node) bool {
return d(n) && n.Parent != nil && a(n.Parent)
}
}
|
[
"func",
"childSelector",
"(",
"a",
",",
"d",
"Selector",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"return",
"d",
"(",
"n",
")",
"&&",
"n",
".",
"Parent",
"!=",
"nil",
"&&",
"a",
"(",
"n",
".",
"Parent",
")",
"\n",
"}",
"\n",
"}"
] |
// childSelector returns a Selector that matches an element if
// it matches d and its parent matches a.
|
[
"childSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"an",
"element",
"if",
"it",
"matches",
"d",
"and",
"its",
"parent",
"matches",
"a",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L577-L581
|
681 |
andybalholm/cascadia
|
selector.go
|
siblingSelector
|
func siblingSelector(s1, s2 Selector, adjacent bool) Selector {
return func(n *html.Node) bool {
if !s2(n) {
return false
}
if adjacent {
for n = n.PrevSibling; n != nil; n = n.PrevSibling {
if n.Type == html.TextNode || n.Type == html.CommentNode {
continue
}
return s1(n)
}
return false
}
// Walk backwards looking for element that matches s1
for c := n.PrevSibling; c != nil; c = c.PrevSibling {
if s1(c) {
return true
}
}
return false
}
}
|
go
|
func siblingSelector(s1, s2 Selector, adjacent bool) Selector {
return func(n *html.Node) bool {
if !s2(n) {
return false
}
if adjacent {
for n = n.PrevSibling; n != nil; n = n.PrevSibling {
if n.Type == html.TextNode || n.Type == html.CommentNode {
continue
}
return s1(n)
}
return false
}
// Walk backwards looking for element that matches s1
for c := n.PrevSibling; c != nil; c = c.PrevSibling {
if s1(c) {
return true
}
}
return false
}
}
|
[
"func",
"siblingSelector",
"(",
"s1",
",",
"s2",
"Selector",
",",
"adjacent",
"bool",
")",
"Selector",
"{",
"return",
"func",
"(",
"n",
"*",
"html",
".",
"Node",
")",
"bool",
"{",
"if",
"!",
"s2",
"(",
"n",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"adjacent",
"{",
"for",
"n",
"=",
"n",
".",
"PrevSibling",
";",
"n",
"!=",
"nil",
";",
"n",
"=",
"n",
".",
"PrevSibling",
"{",
"if",
"n",
".",
"Type",
"==",
"html",
".",
"TextNode",
"||",
"n",
".",
"Type",
"==",
"html",
".",
"CommentNode",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"s1",
"(",
"n",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"// Walk backwards looking for element that matches s1",
"for",
"c",
":=",
"n",
".",
"PrevSibling",
";",
"c",
"!=",
"nil",
";",
"c",
"=",
"c",
".",
"PrevSibling",
"{",
"if",
"s1",
"(",
"c",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}",
"\n",
"}"
] |
// siblingSelector returns a Selector that matches an element
// if it matches s2 and in is preceded by an element that matches s1.
// If adjacent is true, the sibling must be immediately before the element.
|
[
"siblingSelector",
"returns",
"a",
"Selector",
"that",
"matches",
"an",
"element",
"if",
"it",
"matches",
"s2",
"and",
"in",
"is",
"preceded",
"by",
"an",
"element",
"that",
"matches",
"s1",
".",
"If",
"adjacent",
"is",
"true",
"the",
"sibling",
"must",
"be",
"immediately",
"before",
"the",
"element",
"."
] |
680b6a57bda4f657485ad44bdea42342ead737bc
|
https://github.com/andybalholm/cascadia/blob/680b6a57bda4f657485ad44bdea42342ead737bc/selector.go#L586-L611
|
682 |
pkg/browser
|
browser.go
|
OpenFile
|
func OpenFile(path string) error {
path, err := filepath.Abs(path)
if err != nil {
return err
}
return OpenURL("file://" + path)
}
|
go
|
func OpenFile(path string) error {
path, err := filepath.Abs(path)
if err != nil {
return err
}
return OpenURL("file://" + path)
}
|
[
"func",
"OpenFile",
"(",
"path",
"string",
")",
"error",
"{",
"path",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"OpenURL",
"(",
"\"",
"\"",
"+",
"path",
")",
"\n",
"}"
] |
// OpenFile opens new browser window for the file path.
|
[
"OpenFile",
"opens",
"new",
"browser",
"window",
"for",
"the",
"file",
"path",
"."
] |
0a3d74bf9ce488f035cf5bc36f753a711bc74334
|
https://github.com/pkg/browser/blob/0a3d74bf9ce488f035cf5bc36f753a711bc74334/browser.go#L22-L28
|
683 |
pkg/browser
|
browser.go
|
OpenReader
|
func OpenReader(r io.Reader) error {
f, err := ioutil.TempFile("", "browser")
if err != nil {
return fmt.Errorf("browser: could not create temporary file: %v", err)
}
if _, err := io.Copy(f, r); err != nil {
f.Close()
return fmt.Errorf("browser: caching temporary file failed: %v", err)
}
if err := f.Close(); err != nil {
return fmt.Errorf("browser: caching temporary file failed: %v", err)
}
oldname := f.Name()
newname := oldname + ".html"
if err := os.Rename(oldname, newname); err != nil {
return fmt.Errorf("browser: renaming temporary file failed: %v", err)
}
return OpenFile(newname)
}
|
go
|
func OpenReader(r io.Reader) error {
f, err := ioutil.TempFile("", "browser")
if err != nil {
return fmt.Errorf("browser: could not create temporary file: %v", err)
}
if _, err := io.Copy(f, r); err != nil {
f.Close()
return fmt.Errorf("browser: caching temporary file failed: %v", err)
}
if err := f.Close(); err != nil {
return fmt.Errorf("browser: caching temporary file failed: %v", err)
}
oldname := f.Name()
newname := oldname + ".html"
if err := os.Rename(oldname, newname); err != nil {
return fmt.Errorf("browser: renaming temporary file failed: %v", err)
}
return OpenFile(newname)
}
|
[
"func",
"OpenReader",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"f",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"f",
",",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"oldname",
":=",
"f",
".",
"Name",
"(",
")",
"\n",
"newname",
":=",
"oldname",
"+",
"\"",
"\"",
"\n",
"if",
"err",
":=",
"os",
".",
"Rename",
"(",
"oldname",
",",
"newname",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"OpenFile",
"(",
"newname",
")",
"\n",
"}"
] |
// OpenReader consumes the contents of r and presents the
// results in a new browser window.
|
[
"OpenReader",
"consumes",
"the",
"contents",
"of",
"r",
"and",
"presents",
"the",
"results",
"in",
"a",
"new",
"browser",
"window",
"."
] |
0a3d74bf9ce488f035cf5bc36f753a711bc74334
|
https://github.com/pkg/browser/blob/0a3d74bf9ce488f035cf5bc36f753a711bc74334/browser.go#L32-L50
|
684 |
appleboy/gofight
|
example/pat.go
|
PatEngine
|
func PatEngine() *pat.Router {
r := pat.New()
r.Get("/user/{name}", patUserHandler)
r.Get("/", patHelloHandler)
return r
}
|
go
|
func PatEngine() *pat.Router {
r := pat.New()
r.Get("/user/{name}", patUserHandler)
r.Get("/", patHelloHandler)
return r
}
|
[
"func",
"PatEngine",
"(",
")",
"*",
"pat",
".",
"Router",
"{",
"r",
":=",
"pat",
".",
"New",
"(",
")",
"\n\n",
"r",
".",
"Get",
"(",
"\"",
"\"",
",",
"patUserHandler",
")",
"\n",
"r",
".",
"Get",
"(",
"\"",
"\"",
",",
"patHelloHandler",
")",
"\n\n",
"return",
"r",
"\n",
"}"
] |
// PatEngine is pat router.
|
[
"PatEngine",
"is",
"pat",
"router",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/example/pat.go#L21-L28
|
685 |
appleboy/gofight
|
example/httprouter.go
|
HTTPRouterEngine
|
func HTTPRouterEngine() http.Handler {
r := httprouter.New()
r.GET("/", httpRouterHelloHandler)
return r
}
|
go
|
func HTTPRouterEngine() http.Handler {
r := httprouter.New()
r.GET("/", httpRouterHelloHandler)
return r
}
|
[
"func",
"HTTPRouterEngine",
"(",
")",
"http",
".",
"Handler",
"{",
"r",
":=",
"httprouter",
".",
"New",
"(",
")",
"\n\n",
"r",
".",
"GET",
"(",
"\"",
"\"",
",",
"httpRouterHelloHandler",
")",
"\n\n",
"return",
"r",
"\n",
"}"
] |
// HTTPRouterEngine is httprouter router.
|
[
"HTTPRouterEngine",
"is",
"httprouter",
"router",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/example/httprouter.go#L14-L20
|
686 |
appleboy/gofight
|
example/beego.go
|
SayHelloWorld
|
func (c *UserController) SayHelloWorld() {
c.Ctx.ResponseWriter.Status = 200
c.Ctx.ResponseWriter.Write([]byte("Hello, World"))
}
|
go
|
func (c *UserController) SayHelloWorld() {
c.Ctx.ResponseWriter.Status = 200
c.Ctx.ResponseWriter.Write([]byte("Hello, World"))
}
|
[
"func",
"(",
"c",
"*",
"UserController",
")",
"SayHelloWorld",
"(",
")",
"{",
"c",
".",
"Ctx",
".",
"ResponseWriter",
".",
"Status",
"=",
"200",
"\n",
"c",
".",
"Ctx",
".",
"ResponseWriter",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// SayHelloWorld for say hello
|
[
"SayHelloWorld",
"for",
"say",
"hello"
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/example/beego.go#L13-L16
|
687 |
appleboy/gofight
|
example/basic.go
|
BasicEngine
|
func BasicEngine() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("/", basicHelloHandler)
return mux
}
|
go
|
func BasicEngine() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("/", basicHelloHandler)
return mux
}
|
[
"func",
"BasicEngine",
"(",
")",
"http",
".",
"Handler",
"{",
"mux",
":=",
"http",
".",
"NewServeMux",
"(",
")",
"\n",
"mux",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"basicHelloHandler",
")",
"\n\n",
"return",
"mux",
"\n",
"}"
] |
// BasicEngine is basic router.
|
[
"BasicEngine",
"is",
"basic",
"router",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/example/basic.go#L13-L18
|
688 |
appleboy/gofight
|
gofight.go
|
SetDebug
|
func (rc *RequestConfig) SetDebug(enable bool) *RequestConfig {
rc.Debug = enable
return rc
}
|
go
|
func (rc *RequestConfig) SetDebug(enable bool) *RequestConfig {
rc.Debug = enable
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"SetDebug",
"(",
"enable",
"bool",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Debug",
"=",
"enable",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// SetDebug supply enable debug mode.
|
[
"SetDebug",
"supply",
"enable",
"debug",
"mode",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L149-L153
|
689 |
appleboy/gofight
|
gofight.go
|
GET
|
func (rc *RequestConfig) GET(path string) *RequestConfig {
rc.Path = path
rc.Method = "GET"
return rc
}
|
go
|
func (rc *RequestConfig) GET(path string) *RequestConfig {
rc.Path = path
rc.Method = "GET"
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"GET",
"(",
"path",
"string",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Path",
"=",
"path",
"\n",
"rc",
".",
"Method",
"=",
"\"",
"\"",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// GET is request method.
|
[
"GET",
"is",
"request",
"method",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L156-L161
|
690 |
appleboy/gofight
|
gofight.go
|
POST
|
func (rc *RequestConfig) POST(path string) *RequestConfig {
rc.Path = path
rc.Method = "POST"
return rc
}
|
go
|
func (rc *RequestConfig) POST(path string) *RequestConfig {
rc.Path = path
rc.Method = "POST"
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"POST",
"(",
"path",
"string",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Path",
"=",
"path",
"\n",
"rc",
".",
"Method",
"=",
"\"",
"\"",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// POST is request method.
|
[
"POST",
"is",
"request",
"method",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L164-L169
|
691 |
appleboy/gofight
|
gofight.go
|
PUT
|
func (rc *RequestConfig) PUT(path string) *RequestConfig {
rc.Path = path
rc.Method = "PUT"
return rc
}
|
go
|
func (rc *RequestConfig) PUT(path string) *RequestConfig {
rc.Path = path
rc.Method = "PUT"
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"PUT",
"(",
"path",
"string",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Path",
"=",
"path",
"\n",
"rc",
".",
"Method",
"=",
"\"",
"\"",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// PUT is request method.
|
[
"PUT",
"is",
"request",
"method",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L172-L177
|
692 |
appleboy/gofight
|
gofight.go
|
DELETE
|
func (rc *RequestConfig) DELETE(path string) *RequestConfig {
rc.Path = path
rc.Method = "DELETE"
return rc
}
|
go
|
func (rc *RequestConfig) DELETE(path string) *RequestConfig {
rc.Path = path
rc.Method = "DELETE"
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"DELETE",
"(",
"path",
"string",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Path",
"=",
"path",
"\n",
"rc",
".",
"Method",
"=",
"\"",
"\"",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// DELETE is request method.
|
[
"DELETE",
"is",
"request",
"method",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L180-L185
|
693 |
appleboy/gofight
|
gofight.go
|
PATCH
|
func (rc *RequestConfig) PATCH(path string) *RequestConfig {
rc.Path = path
rc.Method = "PATCH"
return rc
}
|
go
|
func (rc *RequestConfig) PATCH(path string) *RequestConfig {
rc.Path = path
rc.Method = "PATCH"
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"PATCH",
"(",
"path",
"string",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Path",
"=",
"path",
"\n",
"rc",
".",
"Method",
"=",
"\"",
"\"",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// PATCH is request method.
|
[
"PATCH",
"is",
"request",
"method",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L188-L193
|
694 |
appleboy/gofight
|
gofight.go
|
HEAD
|
func (rc *RequestConfig) HEAD(path string) *RequestConfig {
rc.Path = path
rc.Method = "HEAD"
return rc
}
|
go
|
func (rc *RequestConfig) HEAD(path string) *RequestConfig {
rc.Path = path
rc.Method = "HEAD"
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"HEAD",
"(",
"path",
"string",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Path",
"=",
"path",
"\n",
"rc",
".",
"Method",
"=",
"\"",
"\"",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// HEAD is request method.
|
[
"HEAD",
"is",
"request",
"method",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L196-L201
|
695 |
appleboy/gofight
|
gofight.go
|
OPTIONS
|
func (rc *RequestConfig) OPTIONS(path string) *RequestConfig {
rc.Path = path
rc.Method = "OPTIONS"
return rc
}
|
go
|
func (rc *RequestConfig) OPTIONS(path string) *RequestConfig {
rc.Path = path
rc.Method = "OPTIONS"
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"OPTIONS",
"(",
"path",
"string",
")",
"*",
"RequestConfig",
"{",
"rc",
".",
"Path",
"=",
"path",
"\n",
"rc",
".",
"Method",
"=",
"\"",
"\"",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// OPTIONS is request method.
|
[
"OPTIONS",
"is",
"request",
"method",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L204-L209
|
696 |
appleboy/gofight
|
gofight.go
|
SetHeader
|
func (rc *RequestConfig) SetHeader(headers H) *RequestConfig {
if len(headers) > 0 {
rc.Headers = headers
}
return rc
}
|
go
|
func (rc *RequestConfig) SetHeader(headers H) *RequestConfig {
if len(headers) > 0 {
rc.Headers = headers
}
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"SetHeader",
"(",
"headers",
"H",
")",
"*",
"RequestConfig",
"{",
"if",
"len",
"(",
"headers",
")",
">",
"0",
"{",
"rc",
".",
"Headers",
"=",
"headers",
"\n",
"}",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// SetHeader supply http header what you defined.
|
[
"SetHeader",
"supply",
"http",
"header",
"what",
"you",
"defined",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L212-L218
|
697 |
appleboy/gofight
|
gofight.go
|
SetJSON
|
func (rc *RequestConfig) SetJSON(body D) *RequestConfig {
if b, err := json.Marshal(body); err == nil {
rc.Body = string(b)
}
return rc
}
|
go
|
func (rc *RequestConfig) SetJSON(body D) *RequestConfig {
if b, err := json.Marshal(body); err == nil {
rc.Body = string(b)
}
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"SetJSON",
"(",
"body",
"D",
")",
"*",
"RequestConfig",
"{",
"if",
"b",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"body",
")",
";",
"err",
"==",
"nil",
"{",
"rc",
".",
"Body",
"=",
"string",
"(",
"b",
")",
"\n",
"}",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// SetJSON supply JSON body.
|
[
"SetJSON",
"supply",
"JSON",
"body",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L221-L227
|
698 |
appleboy/gofight
|
gofight.go
|
SetJSONInterface
|
func (rc *RequestConfig) SetJSONInterface(body interface{}) *RequestConfig {
if b, err := json.Marshal(body); err == nil {
rc.Body = string(b)
}
return rc
}
|
go
|
func (rc *RequestConfig) SetJSONInterface(body interface{}) *RequestConfig {
if b, err := json.Marshal(body); err == nil {
rc.Body = string(b)
}
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"SetJSONInterface",
"(",
"body",
"interface",
"{",
"}",
")",
"*",
"RequestConfig",
"{",
"if",
"b",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"body",
")",
";",
"err",
"==",
"nil",
"{",
"rc",
".",
"Body",
"=",
"string",
"(",
"b",
")",
"\n",
"}",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// SetJSONInterface supply JSON body
|
[
"SetJSONInterface",
"supply",
"JSON",
"body"
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L230-L236
|
699 |
appleboy/gofight
|
gofight.go
|
SetForm
|
func (rc *RequestConfig) SetForm(body H) *RequestConfig {
f := make(url.Values)
for k, v := range body {
f.Set(k, v)
}
rc.Body = f.Encode()
return rc
}
|
go
|
func (rc *RequestConfig) SetForm(body H) *RequestConfig {
f := make(url.Values)
for k, v := range body {
f.Set(k, v)
}
rc.Body = f.Encode()
return rc
}
|
[
"func",
"(",
"rc",
"*",
"RequestConfig",
")",
"SetForm",
"(",
"body",
"H",
")",
"*",
"RequestConfig",
"{",
"f",
":=",
"make",
"(",
"url",
".",
"Values",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"body",
"{",
"f",
".",
"Set",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n\n",
"rc",
".",
"Body",
"=",
"f",
".",
"Encode",
"(",
")",
"\n\n",
"return",
"rc",
"\n",
"}"
] |
// SetForm supply form body.
|
[
"SetForm",
"supply",
"form",
"body",
"."
] |
9341751b2b3c62a14808c372ce615f2f543110a4
|
https://github.com/appleboy/gofight/blob/9341751b2b3c62a14808c372ce615f2f543110a4/gofight.go#L239-L249
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.