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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | 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 |