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
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
14,600 |
doug-martin/goqu
|
expressions.go
|
notILike
|
func notILike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, true)
}
|
go
|
func notILike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, true)
}
|
[
"func",
"notILike",
"(",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkLikeExp",
"(",
"I_LIKE_OP",
",",
"lhs",
",",
"val",
",",
"true",
")",
"\n",
"}"
] |
//used internally to create a NOT ILIKE BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"a",
"NOT",
"ILIKE",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L985-L987
|
14,601 |
doug-martin/goqu
|
expressions.go
|
checkLikeExp
|
func checkLikeExp(op BooleanOperation, lhs Expression, val interface{}, invert bool) BooleanExpression {
rhs := val
switch val.(type) {
case *regexp.Regexp:
if op == LIKE_OP {
op = REGEXP_LIKE_OP
} else if op == I_LIKE_OP {
op = REGEXP_I_LIKE_OP
}
rhs = val.(*regexp.Regexp).String()
}
if invert {
op = operator_inversions[op]
}
return boolean{op: op, lhs: lhs, rhs: rhs}
}
|
go
|
func checkLikeExp(op BooleanOperation, lhs Expression, val interface{}, invert bool) BooleanExpression {
rhs := val
switch val.(type) {
case *regexp.Regexp:
if op == LIKE_OP {
op = REGEXP_LIKE_OP
} else if op == I_LIKE_OP {
op = REGEXP_I_LIKE_OP
}
rhs = val.(*regexp.Regexp).String()
}
if invert {
op = operator_inversions[op]
}
return boolean{op: op, lhs: lhs, rhs: rhs}
}
|
[
"func",
"checkLikeExp",
"(",
"op",
"BooleanOperation",
",",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
",",
"invert",
"bool",
")",
"BooleanExpression",
"{",
"rhs",
":=",
"val",
"\n",
"switch",
"val",
".",
"(",
"type",
")",
"{",
"case",
"*",
"regexp",
".",
"Regexp",
":",
"if",
"op",
"==",
"LIKE_OP",
"{",
"op",
"=",
"REGEXP_LIKE_OP",
"\n",
"}",
"else",
"if",
"op",
"==",
"I_LIKE_OP",
"{",
"op",
"=",
"REGEXP_I_LIKE_OP",
"\n",
"}",
"\n",
"rhs",
"=",
"val",
".",
"(",
"*",
"regexp",
".",
"Regexp",
")",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"if",
"invert",
"{",
"op",
"=",
"operator_inversions",
"[",
"op",
"]",
"\n",
"}",
"\n",
"return",
"boolean",
"{",
"op",
":",
"op",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] |
//checks an like rhs to create the proper like expression for strings or regexps
|
[
"checks",
"an",
"like",
"rhs",
"to",
"create",
"the",
"proper",
"like",
"expression",
"for",
"strings",
"or",
"regexps"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L990-L1005
|
14,602 |
doug-martin/goqu
|
expressions.go
|
between
|
func between(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: BETWEEN_OP, lhs: lhs, rhs: rhs}
}
|
go
|
func between(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: BETWEEN_OP, lhs: lhs, rhs: rhs}
}
|
[
"func",
"between",
"(",
"lhs",
"Expression",
",",
"rhs",
"RangeVal",
")",
"RangeExpression",
"{",
"return",
"ranged",
"{",
"op",
":",
"BETWEEN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] |
//used internally to create an BETWEEN comparison RangeExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"BETWEEN",
"comparison",
"RangeExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1085-L1087
|
14,603 |
doug-martin/goqu
|
expressions.go
|
notBetween
|
func notBetween(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: NBETWEEN_OP, lhs: lhs, rhs: rhs}
}
|
go
|
func notBetween(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: NBETWEEN_OP, lhs: lhs, rhs: rhs}
}
|
[
"func",
"notBetween",
"(",
"lhs",
"Expression",
",",
"rhs",
"RangeVal",
")",
"RangeExpression",
"{",
"return",
"ranged",
"{",
"op",
":",
"NBETWEEN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] |
//used internally to create an NOT BETWEEN comparison RangeExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"NOT",
"BETWEEN",
"comparison",
"RangeExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1090-L1092
|
14,604 |
doug-martin/goqu
|
expressions.go
|
aliased
|
func aliased(exp Expression, alias interface{}) AliasedExpression {
switch v := alias.(type) {
case string:
return aliasExpression{aliased: exp, alias: I(v)}
case IdentifierExpression:
return aliasExpression{aliased: exp, alias: v}
default:
panic(fmt.Sprintf("Cannot create alias from %+v", v))
}
}
|
go
|
func aliased(exp Expression, alias interface{}) AliasedExpression {
switch v := alias.(type) {
case string:
return aliasExpression{aliased: exp, alias: I(v)}
case IdentifierExpression:
return aliasExpression{aliased: exp, alias: v}
default:
panic(fmt.Sprintf("Cannot create alias from %+v", v))
}
}
|
[
"func",
"aliased",
"(",
"exp",
"Expression",
",",
"alias",
"interface",
"{",
"}",
")",
"AliasedExpression",
"{",
"switch",
"v",
":=",
"alias",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"return",
"aliasExpression",
"{",
"aliased",
":",
"exp",
",",
"alias",
":",
"I",
"(",
"v",
")",
"}",
"\n",
"case",
"IdentifierExpression",
":",
"return",
"aliasExpression",
"{",
"aliased",
":",
"exp",
",",
"alias",
":",
"v",
"}",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"}"
] |
//used internally by other expressions to create a new aliased expression
|
[
"used",
"internally",
"by",
"other",
"expressions",
"to",
"create",
"a",
"new",
"aliased",
"expression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1112-L1121
|
14,605 |
doug-martin/goqu
|
expressions.go
|
asc
|
func asc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_ASC, nullSortType: NO_NULLS}
}
|
go
|
func asc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_ASC, nullSortType: NO_NULLS}
}
|
[
"func",
"asc",
"(",
"exp",
"Expression",
")",
"OrderedExpression",
"{",
"return",
"orderedExpression",
"{",
"sortExpression",
":",
"exp",
",",
"direction",
":",
"SORT_ASC",
",",
"nullSortType",
":",
"NO_NULLS",
"}",
"\n",
"}"
] |
//used internally to create a new SORT_ASC OrderedExpression
|
[
"used",
"internally",
"to",
"create",
"a",
"new",
"SORT_ASC",
"OrderedExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1178-L1180
|
14,606 |
doug-martin/goqu
|
expressions.go
|
desc
|
func desc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_DESC, nullSortType: NO_NULLS}
}
|
go
|
func desc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_DESC, nullSortType: NO_NULLS}
}
|
[
"func",
"desc",
"(",
"exp",
"Expression",
")",
"OrderedExpression",
"{",
"return",
"orderedExpression",
"{",
"sortExpression",
":",
"exp",
",",
"direction",
":",
"SORT_DESC",
",",
"nullSortType",
":",
"NO_NULLS",
"}",
"\n",
"}"
] |
//used internally to create a new SORT_DESC OrderedExpression
|
[
"used",
"internally",
"to",
"create",
"a",
"new",
"SORT_DESC",
"OrderedExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1183-L1185
|
14,607 |
doug-martin/goqu
|
expressions.go
|
Func
|
func Func(name string, args ...interface{}) SqlFunctionExpression {
return sqlFunctionExpression{name: name, args: args}
}
|
go
|
func Func(name string, args ...interface{}) SqlFunctionExpression {
return sqlFunctionExpression{name: name, args: args}
}
|
[
"func",
"Func",
"(",
"name",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"SqlFunctionExpression",
"{",
"return",
"sqlFunctionExpression",
"{",
"name",
":",
"name",
",",
"args",
":",
"args",
"}",
"\n",
"}"
] |
//Creates a new SqlFunctionExpression with the given name and arguments
|
[
"Creates",
"a",
"new",
"SqlFunctionExpression",
"with",
"the",
"given",
"name",
"and",
"arguments"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1234-L1236
|
14,608 |
doug-martin/goqu
|
expressions.go
|
colFunc
|
func colFunc(name string, col interface{}) SqlFunctionExpression {
if s, ok := col.(string); ok {
col = I(s)
}
return Func(name, col)
}
|
go
|
func colFunc(name string, col interface{}) SqlFunctionExpression {
if s, ok := col.(string); ok {
col = I(s)
}
return Func(name, col)
}
|
[
"func",
"colFunc",
"(",
"name",
"string",
",",
"col",
"interface",
"{",
"}",
")",
"SqlFunctionExpression",
"{",
"if",
"s",
",",
"ok",
":=",
"col",
".",
"(",
"string",
")",
";",
"ok",
"{",
"col",
"=",
"I",
"(",
"s",
")",
"\n",
"}",
"\n",
"return",
"Func",
"(",
"name",
",",
"col",
")",
"\n",
"}"
] |
//used internally to normalize the column name if passed in as a string it should be turned into an identifier
|
[
"used",
"internally",
"to",
"normalize",
"the",
"column",
"name",
"if",
"passed",
"in",
"as",
"a",
"string",
"it",
"should",
"be",
"turned",
"into",
"an",
"identifier"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1239-L1244
|
14,609 |
doug-martin/goqu
|
expressions.go
|
With
|
func With(recursive bool, name string, subQuery SqlExpression) CommonTableExpression {
return commonExpr{recursive: recursive, name: Literal(name), subQuery: subQuery}
}
|
go
|
func With(recursive bool, name string, subQuery SqlExpression) CommonTableExpression {
return commonExpr{recursive: recursive, name: Literal(name), subQuery: subQuery}
}
|
[
"func",
"With",
"(",
"recursive",
"bool",
",",
"name",
"string",
",",
"subQuery",
"SqlExpression",
")",
"CommonTableExpression",
"{",
"return",
"commonExpr",
"{",
"recursive",
":",
"recursive",
",",
"name",
":",
"Literal",
"(",
"name",
")",
",",
"subQuery",
":",
"subQuery",
"}",
"\n",
"}"
] |
//Creates a new WITH common table expression for a SqlExpression, typically Datasets'. This function is used internally by Dataset when a CTE is added to another Dataset
|
[
"Creates",
"a",
"new",
"WITH",
"common",
"table",
"expression",
"for",
"a",
"SqlExpression",
"typically",
"Datasets",
".",
"This",
"function",
"is",
"used",
"internally",
"by",
"Dataset",
"when",
"a",
"CTE",
"is",
"added",
"to",
"another",
"Dataset"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L1446-L1448
|
14,610 |
doug-martin/goqu
|
dataset_select.go
|
Join
|
func (me *Dataset) Join(table Expression, condition joinExpression) *Dataset {
return me.InnerJoin(table, condition)
}
|
go
|
func (me *Dataset) Join(table Expression, condition joinExpression) *Dataset {
return me.InnerJoin(table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"Join",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"InnerJoin",
"(",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Alias to InnerJoin. See examples.
|
[
"Alias",
"to",
"InnerJoin",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L119-L121
|
14,611 |
doug-martin/goqu
|
dataset_select.go
|
InnerJoin
|
func (me *Dataset) InnerJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(INNER_JOIN, table, condition)
}
|
go
|
func (me *Dataset) InnerJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(INNER_JOIN, table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"InnerJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"INNER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Adds an INNER JOIN clause. See examples.
|
[
"Adds",
"an",
"INNER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L124-L126
|
14,612 |
doug-martin/goqu
|
dataset_select.go
|
FullOuterJoin
|
func (me *Dataset) FullOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_OUTER_JOIN, table, condition)
}
|
go
|
func (me *Dataset) FullOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_OUTER_JOIN, table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"FullOuterJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"FULL_OUTER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Adds a FULL OUTER JOIN clause. See examples.
|
[
"Adds",
"a",
"FULL",
"OUTER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L129-L131
|
14,613 |
doug-martin/goqu
|
dataset_select.go
|
RightOuterJoin
|
func (me *Dataset) RightOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_OUTER_JOIN, table, condition)
}
|
go
|
func (me *Dataset) RightOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_OUTER_JOIN, table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"RightOuterJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"RIGHT_OUTER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Adds a RIGHT OUTER JOIN clause. See examples.
|
[
"Adds",
"a",
"RIGHT",
"OUTER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L134-L136
|
14,614 |
doug-martin/goqu
|
dataset_select.go
|
LeftOuterJoin
|
func (me *Dataset) LeftOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_OUTER_JOIN, table, condition)
}
|
go
|
func (me *Dataset) LeftOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_OUTER_JOIN, table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"LeftOuterJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"LEFT_OUTER_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Adds a LEFT OUTER JOIN clause. See examples.
|
[
"Adds",
"a",
"LEFT",
"OUTER",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L139-L141
|
14,615 |
doug-martin/goqu
|
dataset_select.go
|
FullJoin
|
func (me *Dataset) FullJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_JOIN, table, condition)
}
|
go
|
func (me *Dataset) FullJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_JOIN, table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"FullJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"FULL_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Adds a FULL JOIN clause. See examples.
|
[
"Adds",
"a",
"FULL",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L144-L146
|
14,616 |
doug-martin/goqu
|
dataset_select.go
|
RightJoin
|
func (me *Dataset) RightJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_JOIN, table, condition)
}
|
go
|
func (me *Dataset) RightJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_JOIN, table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"RightJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"RIGHT_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Adds a RIGHT JOIN clause. See examples.
|
[
"Adds",
"a",
"RIGHT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L149-L151
|
14,617 |
doug-martin/goqu
|
dataset_select.go
|
LeftJoin
|
func (me *Dataset) LeftJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_JOIN, table, condition)
}
|
go
|
func (me *Dataset) LeftJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_JOIN, table, condition)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"LeftJoin",
"(",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"LEFT_JOIN",
",",
"table",
",",
"condition",
")",
"\n",
"}"
] |
//Adds a LEFT JOIN clause. See examples.
|
[
"Adds",
"a",
"LEFT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L154-L156
|
14,618 |
doug-martin/goqu
|
dataset_select.go
|
NaturalJoin
|
func (me *Dataset) NaturalJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_JOIN, table, nil)
}
|
go
|
func (me *Dataset) NaturalJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_JOIN, table, nil)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] |
//Adds a NATURAL JOIN clause. See examples.
|
[
"Adds",
"a",
"NATURAL",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L159-L161
|
14,619 |
doug-martin/goqu
|
dataset_select.go
|
NaturalLeftJoin
|
func (me *Dataset) NaturalLeftJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_LEFT_JOIN, table, nil)
}
|
go
|
func (me *Dataset) NaturalLeftJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_LEFT_JOIN, table, nil)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalLeftJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_LEFT_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] |
//Adds a NATURAL LEFT JOIN clause. See examples.
|
[
"Adds",
"a",
"NATURAL",
"LEFT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L164-L166
|
14,620 |
doug-martin/goqu
|
dataset_select.go
|
NaturalRightJoin
|
func (me *Dataset) NaturalRightJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_RIGHT_JOIN, table, nil)
}
|
go
|
func (me *Dataset) NaturalRightJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_RIGHT_JOIN, table, nil)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalRightJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_RIGHT_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] |
//Adds a NATURAL RIGHT JOIN clause. See examples.
|
[
"Adds",
"a",
"NATURAL",
"RIGHT",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L169-L171
|
14,621 |
doug-martin/goqu
|
dataset_select.go
|
NaturalFullJoin
|
func (me *Dataset) NaturalFullJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_FULL_JOIN, table, nil)
}
|
go
|
func (me *Dataset) NaturalFullJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_FULL_JOIN, table, nil)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"NaturalFullJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"NATURAL_FULL_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] |
//Adds a NATURAL FULL JOIN clause. See examples.
|
[
"Adds",
"a",
"NATURAL",
"FULL",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L174-L176
|
14,622 |
doug-martin/goqu
|
dataset_select.go
|
CrossJoin
|
func (me *Dataset) CrossJoin(table Expression) *Dataset {
return me.joinTable(CROSS_JOIN, table, nil)
}
|
go
|
func (me *Dataset) CrossJoin(table Expression) *Dataset {
return me.joinTable(CROSS_JOIN, table, nil)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"CrossJoin",
"(",
"table",
"Expression",
")",
"*",
"Dataset",
"{",
"return",
"me",
".",
"joinTable",
"(",
"CROSS_JOIN",
",",
"table",
",",
"nil",
")",
"\n",
"}"
] |
//Adds a CROSS JOIN clause. See examples.
|
[
"Adds",
"a",
"CROSS",
"JOIN",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L179-L181
|
14,623 |
doug-martin/goqu
|
dataset_select.go
|
joinTable
|
func (me *Dataset) joinTable(joinType JoinType, table Expression, condition joinExpression) *Dataset {
ret := me.copy()
isConditioned := conditioned_join_types[joinType]
ret.clauses.Joins = append(ret.clauses.Joins, JoiningClause{JoinType: joinType, IsConditioned: isConditioned, Table: table, Condition: condition})
return ret
}
|
go
|
func (me *Dataset) joinTable(joinType JoinType, table Expression, condition joinExpression) *Dataset {
ret := me.copy()
isConditioned := conditioned_join_types[joinType]
ret.clauses.Joins = append(ret.clauses.Joins, JoiningClause{JoinType: joinType, IsConditioned: isConditioned, Table: table, Condition: condition})
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"joinTable",
"(",
"joinType",
"JoinType",
",",
"table",
"Expression",
",",
"condition",
"joinExpression",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"isConditioned",
":=",
"conditioned_join_types",
"[",
"joinType",
"]",
"\n",
"ret",
".",
"clauses",
".",
"Joins",
"=",
"append",
"(",
"ret",
".",
"clauses",
".",
"Joins",
",",
"JoiningClause",
"{",
"JoinType",
":",
"joinType",
",",
"IsConditioned",
":",
"isConditioned",
",",
"Table",
":",
"table",
",",
"Condition",
":",
"condition",
"}",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Joins this Datasets table with another
|
[
"Joins",
"this",
"Datasets",
"table",
"with",
"another"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L184-L189
|
14,624 |
doug-martin/goqu
|
dataset_select.go
|
Where
|
func (me *Dataset) Where(expressions ...Expression) *Dataset {
expLen := len(expressions)
if expLen > 0 {
ret := me.copy()
if ret.clauses.Where == nil {
ret.clauses.Where = And(expressions...)
} else {
ret.clauses.Where = ret.clauses.Where.Append(expressions...)
}
return ret
}
return me
}
|
go
|
func (me *Dataset) Where(expressions ...Expression) *Dataset {
expLen := len(expressions)
if expLen > 0 {
ret := me.copy()
if ret.clauses.Where == nil {
ret.clauses.Where = And(expressions...)
} else {
ret.clauses.Where = ret.clauses.Where.Append(expressions...)
}
return ret
}
return me
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"Where",
"(",
"expressions",
"...",
"Expression",
")",
"*",
"Dataset",
"{",
"expLen",
":=",
"len",
"(",
"expressions",
")",
"\n",
"if",
"expLen",
">",
"0",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"if",
"ret",
".",
"clauses",
".",
"Where",
"==",
"nil",
"{",
"ret",
".",
"clauses",
".",
"Where",
"=",
"And",
"(",
"expressions",
"...",
")",
"\n",
"}",
"else",
"{",
"ret",
".",
"clauses",
".",
"Where",
"=",
"ret",
".",
"clauses",
".",
"Where",
".",
"Append",
"(",
"expressions",
"...",
")",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}",
"\n",
"return",
"me",
"\n",
"}"
] |
//Adds a WHERE clause. See examples.
|
[
"Adds",
"a",
"WHERE",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L192-L204
|
14,625 |
doug-martin/goqu
|
dataset_select.go
|
ClearWhere
|
func (me *Dataset) ClearWhere() *Dataset {
ret := me.copy()
ret.clauses.Where = nil
return ret
}
|
go
|
func (me *Dataset) ClearWhere() *Dataset {
ret := me.copy()
ret.clauses.Where = nil
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"ClearWhere",
"(",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Where",
"=",
"nil",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Removes the WHERE clause. See examples.
|
[
"Removes",
"the",
"WHERE",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L207-L211
|
14,626 |
doug-martin/goqu
|
dataset_select.go
|
GroupBy
|
func (me *Dataset) GroupBy(groupBy ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.GroupBy = cols(groupBy...)
return ret
}
|
go
|
func (me *Dataset) GroupBy(groupBy ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.GroupBy = cols(groupBy...)
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"GroupBy",
"(",
"groupBy",
"...",
"interface",
"{",
"}",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"GroupBy",
"=",
"cols",
"(",
"groupBy",
"...",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Adds a GROUP BY clause. See examples.
|
[
"Adds",
"a",
"GROUP",
"BY",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L214-L218
|
14,627 |
doug-martin/goqu
|
dataset_select.go
|
Order
|
func (me *Dataset) Order(order ...OrderedExpression) *Dataset {
ret := me.copy()
ret.clauses.Order = orderList(order...)
return ret
}
|
go
|
func (me *Dataset) Order(order ...OrderedExpression) *Dataset {
ret := me.copy()
ret.clauses.Order = orderList(order...)
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"Order",
"(",
"order",
"...",
"OrderedExpression",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Order",
"=",
"orderList",
"(",
"order",
"...",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Adds a ORDER clause. If the ORDER is currently set it replaces it. See examples.
|
[
"Adds",
"a",
"ORDER",
"clause",
".",
"If",
"the",
"ORDER",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L236-L240
|
14,628 |
doug-martin/goqu
|
dataset_select.go
|
OrderAppend
|
func (me *Dataset) OrderAppend(order ...OrderedExpression) *Dataset {
if me.clauses.Order == nil {
return me.Order(order...)
} else {
ret := me.copy()
ret.clauses.Order = ret.clauses.Order.Append(orderList(order...).Columns()...)
return ret
}
return me
}
|
go
|
func (me *Dataset) OrderAppend(order ...OrderedExpression) *Dataset {
if me.clauses.Order == nil {
return me.Order(order...)
} else {
ret := me.copy()
ret.clauses.Order = ret.clauses.Order.Append(orderList(order...).Columns()...)
return ret
}
return me
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"OrderAppend",
"(",
"order",
"...",
"OrderedExpression",
")",
"*",
"Dataset",
"{",
"if",
"me",
".",
"clauses",
".",
"Order",
"==",
"nil",
"{",
"return",
"me",
".",
"Order",
"(",
"order",
"...",
")",
"\n",
"}",
"else",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Order",
"=",
"ret",
".",
"clauses",
".",
"Order",
".",
"Append",
"(",
"orderList",
"(",
"order",
"...",
")",
".",
"Columns",
"(",
")",
"...",
")",
"\n",
"return",
"ret",
"\n",
"}",
"\n",
"return",
"me",
"\n\n",
"}"
] |
//Adds a more columns to the current ORDER BY clause. If no order has be previously specified it is the same as calling Order. See examples.
|
[
"Adds",
"a",
"more",
"columns",
"to",
"the",
"current",
"ORDER",
"BY",
"clause",
".",
"If",
"no",
"order",
"has",
"be",
"previously",
"specified",
"it",
"is",
"the",
"same",
"as",
"calling",
"Order",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L243-L253
|
14,629 |
doug-martin/goqu
|
dataset_select.go
|
ClearOrder
|
func (me *Dataset) ClearOrder() *Dataset {
ret := me.copy()
ret.clauses.Order = nil
return ret
}
|
go
|
func (me *Dataset) ClearOrder() *Dataset {
ret := me.copy()
ret.clauses.Order = nil
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"ClearOrder",
"(",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Order",
"=",
"nil",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Removes the ORDER BY clause. See examples.
|
[
"Removes",
"the",
"ORDER",
"BY",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L256-L260
|
14,630 |
doug-martin/goqu
|
dataset_select.go
|
Limit
|
func (me *Dataset) Limit(limit uint) *Dataset {
ret := me.copy()
if limit > 0 {
ret.clauses.Limit = limit
} else {
ret.clauses.Limit = nil
}
return ret
}
|
go
|
func (me *Dataset) Limit(limit uint) *Dataset {
ret := me.copy()
if limit > 0 {
ret.clauses.Limit = limit
} else {
ret.clauses.Limit = nil
}
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"Limit",
"(",
"limit",
"uint",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"if",
"limit",
">",
"0",
"{",
"ret",
".",
"clauses",
".",
"Limit",
"=",
"limit",
"\n",
"}",
"else",
"{",
"ret",
".",
"clauses",
".",
"Limit",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Adds a LIMIT clause. If the LIMIT is currently set it replaces it. See examples.
|
[
"Adds",
"a",
"LIMIT",
"clause",
".",
"If",
"the",
"LIMIT",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L263-L271
|
14,631 |
doug-martin/goqu
|
dataset_select.go
|
LimitAll
|
func (me *Dataset) LimitAll() *Dataset {
ret := me.copy()
ret.clauses.Limit = Literal("ALL")
return ret
}
|
go
|
func (me *Dataset) LimitAll() *Dataset {
ret := me.copy()
ret.clauses.Limit = Literal("ALL")
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"LimitAll",
"(",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Limit",
"=",
"Literal",
"(",
"\"",
"\"",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Adds a LIMIT ALL clause. If the LIMIT is currently set it replaces it. See examples.
|
[
"Adds",
"a",
"LIMIT",
"ALL",
"clause",
".",
"If",
"the",
"LIMIT",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L274-L278
|
14,632 |
doug-martin/goqu
|
dataset_select.go
|
Offset
|
func (me *Dataset) Offset(offset uint) *Dataset {
ret := me.copy()
ret.clauses.Offset = offset
return ret
}
|
go
|
func (me *Dataset) Offset(offset uint) *Dataset {
ret := me.copy()
ret.clauses.Offset = offset
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"Offset",
"(",
"offset",
"uint",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Offset",
"=",
"offset",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Adds an OFFSET clause. If the OFFSET is currently set it replaces it. See examples.
|
[
"Adds",
"an",
"OFFSET",
"clause",
".",
"If",
"the",
"OFFSET",
"is",
"currently",
"set",
"it",
"replaces",
"it",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L286-L290
|
14,633 |
doug-martin/goqu
|
dataset_select.go
|
Intersect
|
func (me *Dataset) Intersect(other *Dataset) *Dataset {
ret := me.compoundFromSelf()
ret.clauses.Compounds = append(ret.clauses.Compounds, Intersect(other.compoundFromSelf()))
return ret
}
|
go
|
func (me *Dataset) Intersect(other *Dataset) *Dataset {
ret := me.compoundFromSelf()
ret.clauses.Compounds = append(ret.clauses.Compounds, Intersect(other.compoundFromSelf()))
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"Intersect",
"(",
"other",
"*",
"Dataset",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"compoundFromSelf",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Compounds",
"=",
"append",
"(",
"ret",
".",
"clauses",
".",
"Compounds",
",",
"Intersect",
"(",
"other",
".",
"compoundFromSelf",
"(",
")",
")",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Creates an INTERSECT statement with another dataset.
// If this or the other dataset has a limit or offset it will use that dataset as a subselect in the FROM clause. See examples.
|
[
"Creates",
"an",
"INTERSECT",
"statement",
"with",
"another",
"dataset",
".",
"If",
"this",
"or",
"the",
"other",
"dataset",
"has",
"a",
"limit",
"or",
"offset",
"it",
"will",
"use",
"that",
"dataset",
"as",
"a",
"subselect",
"in",
"the",
"FROM",
"clause",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L315-L319
|
14,634 |
doug-martin/goqu
|
dataset_select.go
|
compoundFromSelf
|
func (me *Dataset) compoundFromSelf() *Dataset {
if me.clauses.Order != nil || me.clauses.Limit != nil {
return me.FromSelf()
}
return me.copy()
}
|
go
|
func (me *Dataset) compoundFromSelf() *Dataset {
if me.clauses.Order != nil || me.clauses.Limit != nil {
return me.FromSelf()
}
return me.copy()
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"compoundFromSelf",
"(",
")",
"*",
"Dataset",
"{",
"if",
"me",
".",
"clauses",
".",
"Order",
"!=",
"nil",
"||",
"me",
".",
"clauses",
".",
"Limit",
"!=",
"nil",
"{",
"return",
"me",
".",
"FromSelf",
"(",
")",
"\n",
"}",
"\n",
"return",
"me",
".",
"copy",
"(",
")",
"\n",
"}"
] |
//Used internally to determine if the dataset needs to use iteself as a source.
//If the dataset has an order or limit it will select from itself
|
[
"Used",
"internally",
"to",
"determine",
"if",
"the",
"dataset",
"needs",
"to",
"use",
"iteself",
"as",
"a",
"source",
".",
"If",
"the",
"dataset",
"has",
"an",
"order",
"or",
"limit",
"it",
"will",
"select",
"from",
"itself"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L331-L336
|
14,635 |
doug-martin/goqu
|
dataset_select.go
|
Returning
|
func (me *Dataset) Returning(returning ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.Returning = cols(returning...)
return ret
}
|
go
|
func (me *Dataset) Returning(returning ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.Returning = cols(returning...)
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"Returning",
"(",
"returning",
"...",
"interface",
"{",
"}",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Returning",
"=",
"cols",
"(",
"returning",
"...",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Adds a RETURNING clause to the dataset if the adapter supports it. Typically used for INSERT, UPDATE or DELETE. See examples.
|
[
"Adds",
"a",
"RETURNING",
"clause",
"to",
"the",
"dataset",
"if",
"the",
"adapter",
"supports",
"it",
".",
"Typically",
"used",
"for",
"INSERT",
"UPDATE",
"or",
"DELETE",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L339-L343
|
14,636 |
doug-martin/goqu
|
dataset_select.go
|
As
|
func (me *Dataset) As(alias string) *Dataset {
ret := me.copy()
ret.clauses.Alias = I(alias)
return ret
}
|
go
|
func (me *Dataset) As(alias string) *Dataset {
ret := me.copy()
ret.clauses.Alias = I(alias)
return ret
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"As",
"(",
"alias",
"string",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"me",
".",
"copy",
"(",
")",
"\n",
"ret",
".",
"clauses",
".",
"Alias",
"=",
"I",
"(",
"alias",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//Sets the alias for this dataset. This is typically used when using a Dataset as a subselect. See examples.
|
[
"Sets",
"the",
"alias",
"for",
"this",
"dataset",
".",
"This",
"is",
"typically",
"used",
"when",
"using",
"a",
"Dataset",
"as",
"a",
"subselect",
".",
"See",
"examples",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L346-L350
|
14,637 |
doug-martin/goqu
|
dataset_select.go
|
selectSqlWriteTo
|
func (me *Dataset) selectSqlWriteTo(buf *SqlBuilder) error {
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return err
}
if me.clauses.SelectDistinct != nil {
if err := me.adapter.SelectDistinctSql(buf, me.clauses.SelectDistinct); err != nil {
return err
}
} else {
if err := me.adapter.SelectSql(buf, me.clauses.Select); err != nil {
return err
}
}
if err := me.adapter.FromSql(buf, me.clauses.From); err != nil {
return err
}
if err := me.adapter.JoinSql(buf, me.clauses.Joins); err != nil {
return err
}
if err := me.adapter.WhereSql(buf, me.clauses.Where); err != nil {
return err
}
if err := me.adapter.GroupBySql(buf, me.clauses.GroupBy); err != nil {
return err
}
if err := me.adapter.HavingSql(buf, me.clauses.Having); err != nil {
return err
}
if err := me.adapter.CompoundsSql(buf, me.clauses.Compounds); err != nil {
return err
}
if err := me.adapter.OrderSql(buf, me.clauses.Order); err != nil {
return err
}
if err := me.adapter.LimitSql(buf, me.clauses.Limit); err != nil {
return err
}
return me.adapter.OffsetSql(buf, me.clauses.Offset)
}
|
go
|
func (me *Dataset) selectSqlWriteTo(buf *SqlBuilder) error {
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return err
}
if me.clauses.SelectDistinct != nil {
if err := me.adapter.SelectDistinctSql(buf, me.clauses.SelectDistinct); err != nil {
return err
}
} else {
if err := me.adapter.SelectSql(buf, me.clauses.Select); err != nil {
return err
}
}
if err := me.adapter.FromSql(buf, me.clauses.From); err != nil {
return err
}
if err := me.adapter.JoinSql(buf, me.clauses.Joins); err != nil {
return err
}
if err := me.adapter.WhereSql(buf, me.clauses.Where); err != nil {
return err
}
if err := me.adapter.GroupBySql(buf, me.clauses.GroupBy); err != nil {
return err
}
if err := me.adapter.HavingSql(buf, me.clauses.Having); err != nil {
return err
}
if err := me.adapter.CompoundsSql(buf, me.clauses.Compounds); err != nil {
return err
}
if err := me.adapter.OrderSql(buf, me.clauses.Order); err != nil {
return err
}
if err := me.adapter.LimitSql(buf, me.clauses.Limit); err != nil {
return err
}
return me.adapter.OffsetSql(buf, me.clauses.Offset)
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"selectSqlWriteTo",
"(",
"buf",
"*",
"SqlBuilder",
")",
"error",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"CommonTablesSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"CommonTables",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"me",
".",
"clauses",
".",
"SelectDistinct",
"!=",
"nil",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"SelectDistinctSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"SelectDistinct",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"SelectSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Select",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"FromSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"From",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"JoinSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Joins",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"WhereSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Where",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"GroupBySql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"GroupBy",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"HavingSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Having",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"CompoundsSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Compounds",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"OrderSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Order",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"LimitSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Limit",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"me",
".",
"adapter",
".",
"OffsetSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Offset",
")",
"\n\n",
"}"
] |
//Does actual sql generation of sql, accepts an sql builder so other methods can call when creating subselects and needing prepared sql.
|
[
"Does",
"actual",
"sql",
"generation",
"of",
"sql",
"accepts",
"an",
"sql",
"builder",
"so",
"other",
"methods",
"can",
"call",
"when",
"creating",
"subselects",
"and",
"needing",
"prepared",
"sql",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_select.go#L366-L405
|
14,638 |
icrowley/fake
|
products.go
|
ProductName
|
func ProductName() string {
productName := lookup(lang, "adjectives", true) + " " + lookup(lang, "nouns", true)
if r.Intn(2) == 1 {
productName = lookup(lang, "adjectives", true) + " " + productName
}
return productName
}
|
go
|
func ProductName() string {
productName := lookup(lang, "adjectives", true) + " " + lookup(lang, "nouns", true)
if r.Intn(2) == 1 {
productName = lookup(lang, "adjectives", true) + " " + productName
}
return productName
}
|
[
"func",
"ProductName",
"(",
")",
"string",
"{",
"productName",
":=",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"+",
"\"",
"\"",
"+",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"\n",
"if",
"r",
".",
"Intn",
"(",
"2",
")",
"==",
"1",
"{",
"productName",
"=",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"+",
"\"",
"\"",
"+",
"productName",
"\n",
"}",
"\n",
"return",
"productName",
"\n",
"}"
] |
// ProductName generates product name
|
[
"ProductName",
"generates",
"product",
"name"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/products.go#L9-L15
|
14,639 |
icrowley/fake
|
products.go
|
Model
|
func Model() string {
seps := []string{"", " ", "-"}
return CharactersN(r.Intn(3)+1) + seps[r.Intn(len(seps))] + Digits()
}
|
go
|
func Model() string {
seps := []string{"", " ", "-"}
return CharactersN(r.Intn(3)+1) + seps[r.Intn(len(seps))] + Digits()
}
|
[
"func",
"Model",
"(",
")",
"string",
"{",
"seps",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"\n",
"return",
"CharactersN",
"(",
"r",
".",
"Intn",
"(",
"3",
")",
"+",
"1",
")",
"+",
"seps",
"[",
"r",
".",
"Intn",
"(",
"len",
"(",
"seps",
")",
")",
"]",
"+",
"Digits",
"(",
")",
"\n",
"}"
] |
// Model generates model name that consists of letters and digits, optionally with a hyphen between them
|
[
"Model",
"generates",
"model",
"name",
"that",
"consists",
"of",
"letters",
"and",
"digits",
"optionally",
"with",
"a",
"hyphen",
"between",
"them"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/products.go#L23-L26
|
14,640 |
icrowley/fake
|
internet.go
|
UserName
|
func UserName() string {
gender := randGender()
switch r.Intn(3) {
case 0:
return lookup("en", gender+"_first_names", false) + lookup(lang, gender+"_last_names", false)
case 1:
return Character() + lookup(lang, gender+"_last_names", false)
default:
return strings.Replace(WordsN(r.Intn(3)+1), " ", "_", -1)
}
}
|
go
|
func UserName() string {
gender := randGender()
switch r.Intn(3) {
case 0:
return lookup("en", gender+"_first_names", false) + lookup(lang, gender+"_last_names", false)
case 1:
return Character() + lookup(lang, gender+"_last_names", false)
default:
return strings.Replace(WordsN(r.Intn(3)+1), " ", "_", -1)
}
}
|
[
"func",
"UserName",
"(",
")",
"string",
"{",
"gender",
":=",
"randGender",
"(",
")",
"\n",
"switch",
"r",
".",
"Intn",
"(",
"3",
")",
"{",
"case",
"0",
":",
"return",
"lookup",
"(",
"\"",
"\"",
",",
"gender",
"+",
"\"",
"\"",
",",
"false",
")",
"+",
"lookup",
"(",
"lang",
",",
"gender",
"+",
"\"",
"\"",
",",
"false",
")",
"\n",
"case",
"1",
":",
"return",
"Character",
"(",
")",
"+",
"lookup",
"(",
"lang",
",",
"gender",
"+",
"\"",
"\"",
",",
"false",
")",
"\n",
"default",
":",
"return",
"strings",
".",
"Replace",
"(",
"WordsN",
"(",
"r",
".",
"Intn",
"(",
"3",
")",
"+",
"1",
")",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"}",
"\n",
"}"
] |
// UserName generates user name in one of the following forms
// first name + last name, letter + last names or concatenation of from 1 to 3 lowercased words
|
[
"UserName",
"generates",
"user",
"name",
"in",
"one",
"of",
"the",
"following",
"forms",
"first",
"name",
"+",
"last",
"name",
"letter",
"+",
"last",
"names",
"or",
"concatenation",
"of",
"from",
"1",
"to",
"3",
"lowercased",
"words"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/internet.go#L12-L22
|
14,641 |
icrowley/fake
|
internet.go
|
IPv4
|
func IPv4() string {
size := 4
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To4().String()
}
|
go
|
func IPv4() string {
size := 4
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To4().String()
}
|
[
"func",
"IPv4",
"(",
")",
"string",
"{",
"size",
":=",
"4",
"\n",
"ip",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"++",
"{",
"ip",
"[",
"i",
"]",
"=",
"byte",
"(",
"r",
".",
"Intn",
"(",
"256",
")",
")",
"\n",
"}",
"\n",
"return",
"net",
".",
"IP",
"(",
"ip",
")",
".",
"To4",
"(",
")",
".",
"String",
"(",
")",
"\n",
"}"
] |
// IPv4 generates IPv4 address
|
[
"IPv4",
"generates",
"IPv4",
"address"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/internet.go#L55-L62
|
14,642 |
icrowley/fake
|
internet.go
|
IPv6
|
func IPv6() string {
size := 16
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To16().String()
}
|
go
|
func IPv6() string {
size := 16
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To16().String()
}
|
[
"func",
"IPv6",
"(",
")",
"string",
"{",
"size",
":=",
"16",
"\n",
"ip",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"++",
"{",
"ip",
"[",
"i",
"]",
"=",
"byte",
"(",
"r",
".",
"Intn",
"(",
"256",
")",
")",
"\n",
"}",
"\n",
"return",
"net",
".",
"IP",
"(",
"ip",
")",
".",
"To16",
"(",
")",
".",
"String",
"(",
")",
"\n",
"}"
] |
// IPv6 generates IPv6 address
|
[
"IPv6",
"generates",
"IPv6",
"address"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/internet.go#L65-L72
|
14,643 |
icrowley/fake
|
general.go
|
DigitsN
|
func DigitsN(n int) string {
digits := make([]rune, n)
for i := 0; i < n; i++ {
digits[i] = numeric[r.Intn(len(numeric))]
}
return string(digits)
}
|
go
|
func DigitsN(n int) string {
digits := make([]rune, n)
for i := 0; i < n; i++ {
digits[i] = numeric[r.Intn(len(numeric))]
}
return string(digits)
}
|
[
"func",
"DigitsN",
"(",
"n",
"int",
")",
"string",
"{",
"digits",
":=",
"make",
"(",
"[",
"]",
"rune",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"digits",
"[",
"i",
"]",
"=",
"numeric",
"[",
"r",
".",
"Intn",
"(",
"len",
"(",
"numeric",
")",
")",
"]",
"\n",
"}",
"\n",
"return",
"string",
"(",
"digits",
")",
"\n",
"}"
] |
// DigitsN returns n digits as a string
|
[
"DigitsN",
"returns",
"n",
"digits",
"as",
"a",
"string"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/general.go#L50-L56
|
14,644 |
icrowley/fake
|
credit_cards.go
|
CreditCardNum
|
func CreditCardNum(vendor string) string {
if vendor != "" {
vendor = strings.ToLower(vendor)
} else {
var vendors []string
for v := range creditCards {
vendors = append(vendors, v)
}
vendor = vendors[r.Intn(len(vendors))]
}
card := creditCards[vendor]
prefix := strconv.Itoa(card.prefixes[r.Intn(len(card.prefixes))])
num := []rune(prefix)
for i := 0; i < card.length-len(prefix); i++ {
num = append(num, genCCDigit(num))
}
return string(num)
}
|
go
|
func CreditCardNum(vendor string) string {
if vendor != "" {
vendor = strings.ToLower(vendor)
} else {
var vendors []string
for v := range creditCards {
vendors = append(vendors, v)
}
vendor = vendors[r.Intn(len(vendors))]
}
card := creditCards[vendor]
prefix := strconv.Itoa(card.prefixes[r.Intn(len(card.prefixes))])
num := []rune(prefix)
for i := 0; i < card.length-len(prefix); i++ {
num = append(num, genCCDigit(num))
}
return string(num)
}
|
[
"func",
"CreditCardNum",
"(",
"vendor",
"string",
")",
"string",
"{",
"if",
"vendor",
"!=",
"\"",
"\"",
"{",
"vendor",
"=",
"strings",
".",
"ToLower",
"(",
"vendor",
")",
"\n",
"}",
"else",
"{",
"var",
"vendors",
"[",
"]",
"string",
"\n",
"for",
"v",
":=",
"range",
"creditCards",
"{",
"vendors",
"=",
"append",
"(",
"vendors",
",",
"v",
")",
"\n",
"}",
"\n",
"vendor",
"=",
"vendors",
"[",
"r",
".",
"Intn",
"(",
"len",
"(",
"vendors",
")",
")",
"]",
"\n",
"}",
"\n",
"card",
":=",
"creditCards",
"[",
"vendor",
"]",
"\n",
"prefix",
":=",
"strconv",
".",
"Itoa",
"(",
"card",
".",
"prefixes",
"[",
"r",
".",
"Intn",
"(",
"len",
"(",
"card",
".",
"prefixes",
")",
")",
"]",
")",
"\n",
"num",
":=",
"[",
"]",
"rune",
"(",
"prefix",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"card",
".",
"length",
"-",
"len",
"(",
"prefix",
")",
";",
"i",
"++",
"{",
"num",
"=",
"append",
"(",
"num",
",",
"genCCDigit",
"(",
"num",
")",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"num",
")",
"\n",
"}"
] |
// CreditCardNum generated credit card number according to the card number rules
|
[
"CreditCardNum",
"generated",
"credit",
"card",
"number",
"according",
"to",
"the",
"card",
"number",
"rules"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/credit_cards.go#L35-L52
|
14,645 |
icrowley/fake
|
addresses.go
|
City
|
func City() string {
city := lookup(lang, "cities", true)
switch r.Intn(5) {
case 0:
return join(cityPrefix(), city)
case 1:
return join(city, citySuffix())
default:
return city
}
}
|
go
|
func City() string {
city := lookup(lang, "cities", true)
switch r.Intn(5) {
case 0:
return join(cityPrefix(), city)
case 1:
return join(city, citySuffix())
default:
return city
}
}
|
[
"func",
"City",
"(",
")",
"string",
"{",
"city",
":=",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"\n",
"switch",
"r",
".",
"Intn",
"(",
"5",
")",
"{",
"case",
"0",
":",
"return",
"join",
"(",
"cityPrefix",
"(",
")",
",",
"city",
")",
"\n",
"case",
"1",
":",
"return",
"join",
"(",
"city",
",",
"citySuffix",
"(",
")",
")",
"\n",
"default",
":",
"return",
"city",
"\n",
"}",
"\n",
"}"
] |
// City generates random city
|
[
"City",
"generates",
"random",
"city"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/addresses.go#L16-L26
|
14,646 |
icrowley/fake
|
lorem_ipsum.go
|
CharactersN
|
func CharactersN(n int) string {
var chars []string
for i := 0; i < n; i++ {
chars = append(chars, Character())
}
return strings.Join(chars, "")
}
|
go
|
func CharactersN(n int) string {
var chars []string
for i := 0; i < n; i++ {
chars = append(chars, Character())
}
return strings.Join(chars, "")
}
|
[
"func",
"CharactersN",
"(",
"n",
"int",
")",
"string",
"{",
"var",
"chars",
"[",
"]",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"chars",
"=",
"append",
"(",
"chars",
",",
"Character",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"chars",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// CharactersN generates n random characters in the given language
|
[
"CharactersN",
"generates",
"n",
"random",
"characters",
"in",
"the",
"given",
"language"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L13-L19
|
14,647 |
icrowley/fake
|
lorem_ipsum.go
|
WordsN
|
func WordsN(n int) string {
words := make([]string, n)
for i := 0; i < n; i++ {
words[i] = Word()
}
return strings.Join(words, " ")
}
|
go
|
func WordsN(n int) string {
words := make([]string, n)
for i := 0; i < n; i++ {
words[i] = Word()
}
return strings.Join(words, " ")
}
|
[
"func",
"WordsN",
"(",
"n",
"int",
")",
"string",
"{",
"words",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"words",
"[",
"i",
"]",
"=",
"Word",
"(",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"words",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// WordsN generates n random words
|
[
"WordsN",
"generates",
"n",
"random",
"words"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L32-L38
|
14,648 |
icrowley/fake
|
lorem_ipsum.go
|
Sentence
|
func Sentence() string {
var words []string
for i := 0; i < 3+r.Intn(12); i++ {
word := Word()
if r.Intn(5) == 0 {
word += ","
}
words = append(words, Word())
}
sentence := strings.Join(words, " ")
if r.Intn(8) == 0 {
sentence += "!"
} else {
sentence += "."
}
return sentence
}
|
go
|
func Sentence() string {
var words []string
for i := 0; i < 3+r.Intn(12); i++ {
word := Word()
if r.Intn(5) == 0 {
word += ","
}
words = append(words, Word())
}
sentence := strings.Join(words, " ")
if r.Intn(8) == 0 {
sentence += "!"
} else {
sentence += "."
}
return sentence
}
|
[
"func",
"Sentence",
"(",
")",
"string",
"{",
"var",
"words",
"[",
"]",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"3",
"+",
"r",
".",
"Intn",
"(",
"12",
")",
";",
"i",
"++",
"{",
"word",
":=",
"Word",
"(",
")",
"\n",
"if",
"r",
".",
"Intn",
"(",
"5",
")",
"==",
"0",
"{",
"word",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"words",
"=",
"append",
"(",
"words",
",",
"Word",
"(",
")",
")",
"\n",
"}",
"\n\n",
"sentence",
":=",
"strings",
".",
"Join",
"(",
"words",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"r",
".",
"Intn",
"(",
"8",
")",
"==",
"0",
"{",
"sentence",
"+=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"sentence",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"sentence",
"\n",
"}"
] |
// Sentence generates random sentence
|
[
"Sentence",
"generates",
"random",
"sentence"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L51-L70
|
14,649 |
icrowley/fake
|
lorem_ipsum.go
|
SentencesN
|
func SentencesN(n int) string {
sentences := make([]string, n)
for i := 0; i < n; i++ {
sentences[i] = Sentence()
}
return strings.Join(sentences, " ")
}
|
go
|
func SentencesN(n int) string {
sentences := make([]string, n)
for i := 0; i < n; i++ {
sentences[i] = Sentence()
}
return strings.Join(sentences, " ")
}
|
[
"func",
"SentencesN",
"(",
"n",
"int",
")",
"string",
"{",
"sentences",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"sentences",
"[",
"i",
"]",
"=",
"Sentence",
"(",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"sentences",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// SentencesN generates n random sentences
|
[
"SentencesN",
"generates",
"n",
"random",
"sentences"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L73-L79
|
14,650 |
icrowley/fake
|
lorem_ipsum.go
|
ParagraphsN
|
func ParagraphsN(n int) string {
var paragraphs []string
for i := 0; i < n; i++ {
paragraphs = append(paragraphs, Paragraph())
}
return strings.Join(paragraphs, "\t")
}
|
go
|
func ParagraphsN(n int) string {
var paragraphs []string
for i := 0; i < n; i++ {
paragraphs = append(paragraphs, Paragraph())
}
return strings.Join(paragraphs, "\t")
}
|
[
"func",
"ParagraphsN",
"(",
"n",
"int",
")",
"string",
"{",
"var",
"paragraphs",
"[",
"]",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"paragraphs",
"=",
"append",
"(",
"paragraphs",
",",
"Paragraph",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"paragraphs",
",",
"\"",
"\\t",
"\"",
")",
"\n",
"}"
] |
// ParagraphsN generates n paragraphs
|
[
"ParagraphsN",
"generates",
"n",
"paragraphs"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/lorem_ipsum.go#L92-L98
|
14,651 |
icrowley/fake
|
dates.go
|
Year
|
func Year(from, to int) int {
n := r.Intn(to-from) + 1
return from + n
}
|
go
|
func Year(from, to int) int {
n := r.Intn(to-from) + 1
return from + n
}
|
[
"func",
"Year",
"(",
"from",
",",
"to",
"int",
")",
"int",
"{",
"n",
":=",
"r",
".",
"Intn",
"(",
"to",
"-",
"from",
")",
"+",
"1",
"\n",
"return",
"from",
"+",
"n",
"\n",
"}"
] |
// Year generates year using the given boundaries
|
[
"Year",
"generates",
"year",
"using",
"the",
"given",
"boundaries"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/dates.go#L39-L42
|
14,652 |
icrowley/fake
|
fake.go
|
GetLangs
|
func GetLangs() []string {
var langs []string
for k, v := range data {
if v.isDir && k != "/" && k != "/data" {
langs = append(langs, strings.Replace(k, "/data/", "", 1))
}
}
return langs
}
|
go
|
func GetLangs() []string {
var langs []string
for k, v := range data {
if v.isDir && k != "/" && k != "/data" {
langs = append(langs, strings.Replace(k, "/data/", "", 1))
}
}
return langs
}
|
[
"func",
"GetLangs",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"langs",
"[",
"]",
"string",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"data",
"{",
"if",
"v",
".",
"isDir",
"&&",
"k",
"!=",
"\"",
"\"",
"&&",
"k",
"!=",
"\"",
"\"",
"{",
"langs",
"=",
"append",
"(",
"langs",
",",
"strings",
".",
"Replace",
"(",
"k",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"langs",
"\n",
"}"
] |
// GetLangs returns a slice of available languages
|
[
"GetLangs",
"returns",
"a",
"slice",
"of",
"available",
"languages"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/fake.go#L94-L102
|
14,653 |
icrowley/fake
|
fake.go
|
SetLang
|
func SetLang(newLang string) error {
found := false
for _, l := range availLangs {
if newLang == l {
found = true
break
}
}
if !found {
return ErrNoLanguageFn(newLang)
}
lang = newLang
return nil
}
|
go
|
func SetLang(newLang string) error {
found := false
for _, l := range availLangs {
if newLang == l {
found = true
break
}
}
if !found {
return ErrNoLanguageFn(newLang)
}
lang = newLang
return nil
}
|
[
"func",
"SetLang",
"(",
"newLang",
"string",
")",
"error",
"{",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"availLangs",
"{",
"if",
"newLang",
"==",
"l",
"{",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"return",
"ErrNoLanguageFn",
"(",
"newLang",
")",
"\n",
"}",
"\n",
"lang",
"=",
"newLang",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetLang sets the language in which the data should be generated
// returns error if passed language is not available
|
[
"SetLang",
"sets",
"the",
"language",
"in",
"which",
"the",
"data",
"should",
"be",
"generated",
"returns",
"error",
"if",
"passed",
"language",
"is",
"not",
"available"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/fake.go#L106-L119
|
14,654 |
icrowley/fake
|
jobs.go
|
JobTitle
|
func JobTitle() string {
job := lookup(lang, "jobs", true)
return strings.Replace(job, "#{N}", jobTitleSuffix(), 1)
}
|
go
|
func JobTitle() string {
job := lookup(lang, "jobs", true)
return strings.Replace(job, "#{N}", jobTitleSuffix(), 1)
}
|
[
"func",
"JobTitle",
"(",
")",
"string",
"{",
"job",
":=",
"lookup",
"(",
"lang",
",",
"\"",
"\"",
",",
"true",
")",
"\n",
"return",
"strings",
".",
"Replace",
"(",
"job",
",",
"\"",
"\"",
",",
"jobTitleSuffix",
"(",
")",
",",
"1",
")",
"\n",
"}"
] |
// JobTitle generates job title
|
[
"JobTitle",
"generates",
"job",
"title"
] |
4178557ae428460c3780a381c824a1f3aceb6325
|
https://github.com/icrowley/fake/blob/4178557ae428460c3780a381c824a1f3aceb6325/jobs.go#L13-L16
|
14,655 |
mgutz/logxi
|
v1/env.go
|
ProcessLogxiFormatEnv
|
func ProcessLogxiFormatEnv(env string) {
logxiFormat = env
m := parseKVList(logxiFormat, ",")
formatterFormat := ""
tFormat := ""
for key, value := range m {
switch key {
default:
formatterFormat = key
case "t":
tFormat = value
case "pretty":
isPretty = value != "false" && value != "0"
case "maxcol":
col, err := strconv.Atoi(value)
if err == nil {
maxCol = col
} else {
maxCol = defaultMaxCol
}
case "context":
lines, err := strconv.Atoi(value)
if err == nil {
contextLines = lines
} else {
contextLines = defaultContextLines
}
case "LTSV":
formatterFormat = "text"
AssignmentChar = ltsvAssignmentChar
Separator = ltsvSeparator
}
}
if formatterFormat == "" || formatterCreators[formatterFormat] == nil {
formatterFormat = defaultFormat
}
logxiFormat = formatterFormat
if tFormat == "" {
tFormat = defaultTimeFormat
}
timeFormat = tFormat
}
|
go
|
func ProcessLogxiFormatEnv(env string) {
logxiFormat = env
m := parseKVList(logxiFormat, ",")
formatterFormat := ""
tFormat := ""
for key, value := range m {
switch key {
default:
formatterFormat = key
case "t":
tFormat = value
case "pretty":
isPretty = value != "false" && value != "0"
case "maxcol":
col, err := strconv.Atoi(value)
if err == nil {
maxCol = col
} else {
maxCol = defaultMaxCol
}
case "context":
lines, err := strconv.Atoi(value)
if err == nil {
contextLines = lines
} else {
contextLines = defaultContextLines
}
case "LTSV":
formatterFormat = "text"
AssignmentChar = ltsvAssignmentChar
Separator = ltsvSeparator
}
}
if formatterFormat == "" || formatterCreators[formatterFormat] == nil {
formatterFormat = defaultFormat
}
logxiFormat = formatterFormat
if tFormat == "" {
tFormat = defaultTimeFormat
}
timeFormat = tFormat
}
|
[
"func",
"ProcessLogxiFormatEnv",
"(",
"env",
"string",
")",
"{",
"logxiFormat",
"=",
"env",
"\n",
"m",
":=",
"parseKVList",
"(",
"logxiFormat",
",",
"\"",
"\"",
")",
"\n",
"formatterFormat",
":=",
"\"",
"\"",
"\n",
"tFormat",
":=",
"\"",
"\"",
"\n",
"for",
"key",
",",
"value",
":=",
"range",
"m",
"{",
"switch",
"key",
"{",
"default",
":",
"formatterFormat",
"=",
"key",
"\n",
"case",
"\"",
"\"",
":",
"tFormat",
"=",
"value",
"\n",
"case",
"\"",
"\"",
":",
"isPretty",
"=",
"value",
"!=",
"\"",
"\"",
"&&",
"value",
"!=",
"\"",
"\"",
"\n",
"case",
"\"",
"\"",
":",
"col",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"value",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"maxCol",
"=",
"col",
"\n",
"}",
"else",
"{",
"maxCol",
"=",
"defaultMaxCol",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"lines",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"value",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"contextLines",
"=",
"lines",
"\n",
"}",
"else",
"{",
"contextLines",
"=",
"defaultContextLines",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"formatterFormat",
"=",
"\"",
"\"",
"\n",
"AssignmentChar",
"=",
"ltsvAssignmentChar",
"\n",
"Separator",
"=",
"ltsvSeparator",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"formatterFormat",
"==",
"\"",
"\"",
"||",
"formatterCreators",
"[",
"formatterFormat",
"]",
"==",
"nil",
"{",
"formatterFormat",
"=",
"defaultFormat",
"\n",
"}",
"\n",
"logxiFormat",
"=",
"formatterFormat",
"\n",
"if",
"tFormat",
"==",
"\"",
"\"",
"{",
"tFormat",
"=",
"defaultTimeFormat",
"\n",
"}",
"\n",
"timeFormat",
"=",
"tFormat",
"\n",
"}"
] |
// ProcessLogxiFormatEnv parses LOGXI_FORMAT
|
[
"ProcessLogxiFormatEnv",
"parses",
"LOGXI_FORMAT"
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/env.go#L46-L87
|
14,656 |
mgutz/logxi
|
v1/env.go
|
ProcessLogxiEnv
|
func ProcessLogxiEnv(env string) {
logxiEnable := env
if logxiEnable == "" {
logxiEnable = defaultLogxiEnv
}
logxiNameLevelMap = map[string]int{}
m := parseKVList(logxiEnable, ",")
if m == nil {
logxiNameLevelMap["*"] = defaultLevel
}
for key, value := range m {
if strings.HasPrefix(key, "-") {
// LOGXI=*,-foo => disable foo
logxiNameLevelMap[key[1:]] = LevelOff
} else if value == "" {
// LOGXI=* => default to all
logxiNameLevelMap[key] = LevelAll
} else {
// LOGXI=*=ERR => use user-specified level
level := LevelAtoi[value]
if level == 0 {
InternalLog.Error("Unknown level in LOGXI environment variable", "key", key, "value", value, "LOGXI", env)
level = defaultLevel
}
logxiNameLevelMap[key] = level
}
}
// must always have global default, otherwise errs may get eaten up
if _, ok := logxiNameLevelMap["*"]; !ok {
logxiNameLevelMap["*"] = LevelError
}
}
|
go
|
func ProcessLogxiEnv(env string) {
logxiEnable := env
if logxiEnable == "" {
logxiEnable = defaultLogxiEnv
}
logxiNameLevelMap = map[string]int{}
m := parseKVList(logxiEnable, ",")
if m == nil {
logxiNameLevelMap["*"] = defaultLevel
}
for key, value := range m {
if strings.HasPrefix(key, "-") {
// LOGXI=*,-foo => disable foo
logxiNameLevelMap[key[1:]] = LevelOff
} else if value == "" {
// LOGXI=* => default to all
logxiNameLevelMap[key] = LevelAll
} else {
// LOGXI=*=ERR => use user-specified level
level := LevelAtoi[value]
if level == 0 {
InternalLog.Error("Unknown level in LOGXI environment variable", "key", key, "value", value, "LOGXI", env)
level = defaultLevel
}
logxiNameLevelMap[key] = level
}
}
// must always have global default, otherwise errs may get eaten up
if _, ok := logxiNameLevelMap["*"]; !ok {
logxiNameLevelMap["*"] = LevelError
}
}
|
[
"func",
"ProcessLogxiEnv",
"(",
"env",
"string",
")",
"{",
"logxiEnable",
":=",
"env",
"\n",
"if",
"logxiEnable",
"==",
"\"",
"\"",
"{",
"logxiEnable",
"=",
"defaultLogxiEnv",
"\n",
"}",
"\n\n",
"logxiNameLevelMap",
"=",
"map",
"[",
"string",
"]",
"int",
"{",
"}",
"\n",
"m",
":=",
"parseKVList",
"(",
"logxiEnable",
",",
"\"",
"\"",
")",
"\n",
"if",
"m",
"==",
"nil",
"{",
"logxiNameLevelMap",
"[",
"\"",
"\"",
"]",
"=",
"defaultLevel",
"\n",
"}",
"\n",
"for",
"key",
",",
"value",
":=",
"range",
"m",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"{",
"// LOGXI=*,-foo => disable foo",
"logxiNameLevelMap",
"[",
"key",
"[",
"1",
":",
"]",
"]",
"=",
"LevelOff",
"\n",
"}",
"else",
"if",
"value",
"==",
"\"",
"\"",
"{",
"// LOGXI=* => default to all",
"logxiNameLevelMap",
"[",
"key",
"]",
"=",
"LevelAll",
"\n",
"}",
"else",
"{",
"// LOGXI=*=ERR => use user-specified level",
"level",
":=",
"LevelAtoi",
"[",
"value",
"]",
"\n",
"if",
"level",
"==",
"0",
"{",
"InternalLog",
".",
"Error",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"key",
",",
"\"",
"\"",
",",
"value",
",",
"\"",
"\"",
",",
"env",
")",
"\n",
"level",
"=",
"defaultLevel",
"\n",
"}",
"\n",
"logxiNameLevelMap",
"[",
"key",
"]",
"=",
"level",
"\n",
"}",
"\n",
"}",
"\n\n",
"// must always have global default, otherwise errs may get eaten up",
"if",
"_",
",",
"ok",
":=",
"logxiNameLevelMap",
"[",
"\"",
"\"",
"]",
";",
"!",
"ok",
"{",
"logxiNameLevelMap",
"[",
"\"",
"\"",
"]",
"=",
"LevelError",
"\n",
"}",
"\n",
"}"
] |
// ProcessLogxiEnv parses LOGXI variable
|
[
"ProcessLogxiEnv",
"parses",
"LOGXI",
"variable"
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/env.go#L90-L123
|
14,657 |
mgutz/logxi
|
v1/env.go
|
ProcessLogxiColorsEnv
|
func ProcessLogxiColorsEnv(env string) {
colors := env
if colors == "" {
colors = defaultLogxiColorsEnv
} else if colors == "*=off" {
// disable all colors
disableColors = true
}
theme = parseTheme(colors)
}
|
go
|
func ProcessLogxiColorsEnv(env string) {
colors := env
if colors == "" {
colors = defaultLogxiColorsEnv
} else if colors == "*=off" {
// disable all colors
disableColors = true
}
theme = parseTheme(colors)
}
|
[
"func",
"ProcessLogxiColorsEnv",
"(",
"env",
"string",
")",
"{",
"colors",
":=",
"env",
"\n",
"if",
"colors",
"==",
"\"",
"\"",
"{",
"colors",
"=",
"defaultLogxiColorsEnv",
"\n",
"}",
"else",
"if",
"colors",
"==",
"\"",
"\"",
"{",
"// disable all colors",
"disableColors",
"=",
"true",
"\n",
"}",
"\n",
"theme",
"=",
"parseTheme",
"(",
"colors",
")",
"\n",
"}"
] |
// ProcessLogxiColorsEnv parases LOGXI_COLORS
|
[
"ProcessLogxiColorsEnv",
"parases",
"LOGXI_COLORS"
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/env.go#L157-L166
|
14,658 |
mgutz/logxi
|
v1/jsonFormatter.go
|
Format
|
func (jf *JSONFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
const lead = `", "`
const colon = `":"`
buf.WriteString(`{"`)
buf.WriteString(KeyMap.Time)
buf.WriteString(`":"`)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(`", "`)
buf.WriteString(KeyMap.PID)
buf.WriteString(`":"`)
buf.WriteString(pidStr)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Level)
buf.WriteString(`":"`)
buf.WriteString(LevelMap[level])
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Name)
buf.WriteString(`":"`)
buf.WriteString(jf.name)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Message)
buf.WriteString(`":`)
jf.appendValue(buf, msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
jf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
jf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
jf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteString("}\n")
buf.WriteTo(writer)
}
|
go
|
func (jf *JSONFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
const lead = `", "`
const colon = `":"`
buf.WriteString(`{"`)
buf.WriteString(KeyMap.Time)
buf.WriteString(`":"`)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(`", "`)
buf.WriteString(KeyMap.PID)
buf.WriteString(`":"`)
buf.WriteString(pidStr)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Level)
buf.WriteString(`":"`)
buf.WriteString(LevelMap[level])
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Name)
buf.WriteString(`":"`)
buf.WriteString(jf.name)
buf.WriteString(`", "`)
buf.WriteString(KeyMap.Message)
buf.WriteString(`":`)
jf.appendValue(buf, msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
jf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
jf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
jf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
jf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteString("}\n")
buf.WriteTo(writer)
}
|
[
"func",
"(",
"jf",
"*",
"JSONFormatter",
")",
"Format",
"(",
"writer",
"io",
".",
"Writer",
",",
"level",
"int",
",",
"msg",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"buf",
":=",
"pool",
".",
"Get",
"(",
")",
"\n",
"defer",
"pool",
".",
"Put",
"(",
"buf",
")",
"\n\n",
"const",
"lead",
"=",
"`\", \"`",
"\n",
"const",
"colon",
"=",
"`\":\"`",
"\n\n",
"buf",
".",
"WriteString",
"(",
"`{\"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"KeyMap",
".",
"Time",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"`\":\"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Format",
"(",
"timeFormat",
")",
")",
"\n\n",
"buf",
".",
"WriteString",
"(",
"`\", \"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"KeyMap",
".",
"PID",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"`\":\"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"pidStr",
")",
"\n\n",
"buf",
".",
"WriteString",
"(",
"`\", \"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"KeyMap",
".",
"Level",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"`\":\"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"LevelMap",
"[",
"level",
"]",
")",
"\n\n",
"buf",
".",
"WriteString",
"(",
"`\", \"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"KeyMap",
".",
"Name",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"`\":\"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"jf",
".",
"name",
")",
"\n\n",
"buf",
".",
"WriteString",
"(",
"`\", \"`",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"KeyMap",
".",
"Message",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"`\":`",
")",
"\n",
"jf",
".",
"appendValue",
"(",
"buf",
",",
"msg",
")",
"\n\n",
"var",
"lenArgs",
"=",
"len",
"(",
"args",
")",
"\n",
"if",
"lenArgs",
">",
"0",
"{",
"if",
"lenArgs",
"==",
"1",
"{",
"jf",
".",
"set",
"(",
"buf",
",",
"singleArgKey",
",",
"args",
"[",
"0",
"]",
")",
"\n",
"}",
"else",
"if",
"lenArgs",
"%",
"2",
"==",
"0",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"lenArgs",
";",
"i",
"+=",
"2",
"{",
"if",
"key",
",",
"ok",
":=",
"args",
"[",
"i",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"if",
"key",
"==",
"\"",
"\"",
"{",
"// show key is invalid",
"jf",
".",
"set",
"(",
"buf",
",",
"badKeyAtIndex",
"(",
"i",
")",
",",
"args",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"else",
"{",
"jf",
".",
"set",
"(",
"buf",
",",
"key",
",",
"args",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// show key is invalid",
"jf",
".",
"set",
"(",
"buf",
",",
"badKeyAtIndex",
"(",
"i",
")",
",",
"args",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"jf",
".",
"set",
"(",
"buf",
",",
"warnImbalancedKey",
",",
"args",
")",
"\n",
"}",
"\n",
"}",
"\n",
"buf",
".",
"WriteString",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"buf",
".",
"WriteTo",
"(",
"writer",
")",
"\n",
"}"
] |
// Format formats log entry as JSON.
|
[
"Format",
"formats",
"log",
"entry",
"as",
"JSON",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/jsonFormatter.go#L134-L190
|
14,659 |
mgutz/logxi
|
v1/formatter.go
|
RegisterFormatFactory
|
func RegisterFormatFactory(kind string, fn CreateFormatterFunc) {
if kind == "" {
panic("kind is empty string")
}
if fn == nil {
panic("creator is nil")
}
formatterCreators[kind] = fn
}
|
go
|
func RegisterFormatFactory(kind string, fn CreateFormatterFunc) {
if kind == "" {
panic("kind is empty string")
}
if fn == nil {
panic("creator is nil")
}
formatterCreators[kind] = fn
}
|
[
"func",
"RegisterFormatFactory",
"(",
"kind",
"string",
",",
"fn",
"CreateFormatterFunc",
")",
"{",
"if",
"kind",
"==",
"\"",
"\"",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"fn",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"formatterCreators",
"[",
"kind",
"]",
"=",
"fn",
"\n",
"}"
] |
// RegisterFormatFactory registers a format factory function.
|
[
"RegisterFormatFactory",
"registers",
"a",
"format",
"factory",
"function",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/formatter.go#L53-L61
|
14,660 |
mgutz/logxi
|
v1/happyDevFormatter.go
|
NewHappyDevFormatter
|
func NewHappyDevFormatter(name string) *HappyDevFormatter {
jf := NewJSONFormatter(name)
return &HappyDevFormatter{
name: name,
jsonFormatter: jf,
}
}
|
go
|
func NewHappyDevFormatter(name string) *HappyDevFormatter {
jf := NewJSONFormatter(name)
return &HappyDevFormatter{
name: name,
jsonFormatter: jf,
}
}
|
[
"func",
"NewHappyDevFormatter",
"(",
"name",
"string",
")",
"*",
"HappyDevFormatter",
"{",
"jf",
":=",
"NewJSONFormatter",
"(",
"name",
")",
"\n",
"return",
"&",
"HappyDevFormatter",
"{",
"name",
":",
"name",
",",
"jsonFormatter",
":",
"jf",
",",
"}",
"\n",
"}"
] |
// NewHappyDevFormatter returns a new instance of HappyDevFormatter.
|
[
"NewHappyDevFormatter",
"returns",
"a",
"new",
"instance",
"of",
"HappyDevFormatter",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/happyDevFormatter.go#L120-L126
|
14,661 |
mgutz/logxi
|
v1/happyDevFormatter.go
|
writeString
|
func (hd *HappyDevFormatter) writeString(buf bufferWriter, s string) {
buf.WriteString(s)
hd.col += len(s)
}
|
go
|
func (hd *HappyDevFormatter) writeString(buf bufferWriter, s string) {
buf.WriteString(s)
hd.col += len(s)
}
|
[
"func",
"(",
"hd",
"*",
"HappyDevFormatter",
")",
"writeString",
"(",
"buf",
"bufferWriter",
",",
"s",
"string",
")",
"{",
"buf",
".",
"WriteString",
"(",
"s",
")",
"\n",
"hd",
".",
"col",
"+=",
"len",
"(",
"s",
")",
"\n",
"}"
] |
// Write a string and tracks the position of the string so we can break lines
// cleanly. Do not send ANSI escape sequences, just raw strings
|
[
"Write",
"a",
"string",
"and",
"tracks",
"the",
"position",
"of",
"the",
"string",
"so",
"we",
"can",
"break",
"lines",
"cleanly",
".",
"Do",
"not",
"send",
"ANSI",
"escape",
"sequences",
"just",
"raw",
"strings"
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/happyDevFormatter.go#L169-L172
|
14,662 |
mgutz/logxi
|
v1/defaultLogger.go
|
NewLogger
|
func NewLogger(writer io.Writer, name string) Logger {
formatter, err := createFormatter(name, logxiFormat)
if err != nil {
panic("Could not create formatter")
}
return NewLogger3(writer, name, formatter)
}
|
go
|
func NewLogger(writer io.Writer, name string) Logger {
formatter, err := createFormatter(name, logxiFormat)
if err != nil {
panic("Could not create formatter")
}
return NewLogger3(writer, name, formatter)
}
|
[
"func",
"NewLogger",
"(",
"writer",
"io",
".",
"Writer",
",",
"name",
"string",
")",
"Logger",
"{",
"formatter",
",",
"err",
":=",
"createFormatter",
"(",
"name",
",",
"logxiFormat",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"NewLogger3",
"(",
"writer",
",",
"name",
",",
"formatter",
")",
"\n",
"}"
] |
// NewLogger creates a new default logger. If writer is not concurrent
// safe, wrap it with NewConcurrentWriter.
|
[
"NewLogger",
"creates",
"a",
"new",
"default",
"logger",
".",
"If",
"writer",
"is",
"not",
"concurrent",
"safe",
"wrap",
"it",
"with",
"NewConcurrentWriter",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L18-L24
|
14,663 |
mgutz/logxi
|
v1/defaultLogger.go
|
NewLogger3
|
func NewLogger3(writer io.Writer, name string, formatter Formatter) Logger {
var level int
if name != "__logxi" {
// if err is returned, then it means the log is disabled
level = getLogLevel(name)
if level == LevelOff {
return NullLog
}
}
log := &DefaultLogger{
formatter: formatter,
writer: writer,
name: name,
level: level,
}
// TODO loggers will be used when watching changes to configuration such
// as in consul, etcd
loggers.Lock()
loggers.loggers[name] = log
loggers.Unlock()
return log
}
|
go
|
func NewLogger3(writer io.Writer, name string, formatter Formatter) Logger {
var level int
if name != "__logxi" {
// if err is returned, then it means the log is disabled
level = getLogLevel(name)
if level == LevelOff {
return NullLog
}
}
log := &DefaultLogger{
formatter: formatter,
writer: writer,
name: name,
level: level,
}
// TODO loggers will be used when watching changes to configuration such
// as in consul, etcd
loggers.Lock()
loggers.loggers[name] = log
loggers.Unlock()
return log
}
|
[
"func",
"NewLogger3",
"(",
"writer",
"io",
".",
"Writer",
",",
"name",
"string",
",",
"formatter",
"Formatter",
")",
"Logger",
"{",
"var",
"level",
"int",
"\n",
"if",
"name",
"!=",
"\"",
"\"",
"{",
"// if err is returned, then it means the log is disabled",
"level",
"=",
"getLogLevel",
"(",
"name",
")",
"\n",
"if",
"level",
"==",
"LevelOff",
"{",
"return",
"NullLog",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
":=",
"&",
"DefaultLogger",
"{",
"formatter",
":",
"formatter",
",",
"writer",
":",
"writer",
",",
"name",
":",
"name",
",",
"level",
":",
"level",
",",
"}",
"\n\n",
"// TODO loggers will be used when watching changes to configuration such",
"// as in consul, etcd",
"loggers",
".",
"Lock",
"(",
")",
"\n",
"loggers",
".",
"loggers",
"[",
"name",
"]",
"=",
"log",
"\n",
"loggers",
".",
"Unlock",
"(",
")",
"\n",
"return",
"log",
"\n",
"}"
] |
// NewLogger3 creates a new logger with a writer, name and formatter. If writer is not concurrent
// safe, wrap it with NewConcurrentWriter.
|
[
"NewLogger3",
"creates",
"a",
"new",
"logger",
"with",
"a",
"writer",
"name",
"and",
"formatter",
".",
"If",
"writer",
"is",
"not",
"concurrent",
"safe",
"wrap",
"it",
"with",
"NewConcurrentWriter",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L28-L51
|
14,664 |
mgutz/logxi
|
v1/defaultLogger.go
|
Trace
|
func (l *DefaultLogger) Trace(msg string, args ...interface{}) {
l.Log(LevelTrace, msg, args)
}
|
go
|
func (l *DefaultLogger) Trace(msg string, args ...interface{}) {
l.Log(LevelTrace, msg, args)
}
|
[
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Trace",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Log",
"(",
"LevelTrace",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] |
// Trace logs a debug entry.
|
[
"Trace",
"logs",
"a",
"debug",
"entry",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L59-L61
|
14,665 |
mgutz/logxi
|
v1/defaultLogger.go
|
Debug
|
func (l *DefaultLogger) Debug(msg string, args ...interface{}) {
l.Log(LevelDebug, msg, args)
}
|
go
|
func (l *DefaultLogger) Debug(msg string, args ...interface{}) {
l.Log(LevelDebug, msg, args)
}
|
[
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Debug",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Log",
"(",
"LevelDebug",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] |
// Debug logs a debug entry.
|
[
"Debug",
"logs",
"a",
"debug",
"entry",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L64-L66
|
14,666 |
mgutz/logxi
|
v1/defaultLogger.go
|
Info
|
func (l *DefaultLogger) Info(msg string, args ...interface{}) {
l.Log(LevelInfo, msg, args)
}
|
go
|
func (l *DefaultLogger) Info(msg string, args ...interface{}) {
l.Log(LevelInfo, msg, args)
}
|
[
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Info",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"Log",
"(",
"LevelInfo",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] |
// Info logs an info entry.
|
[
"Info",
"logs",
"an",
"info",
"entry",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L69-L71
|
14,667 |
mgutz/logxi
|
v1/defaultLogger.go
|
Warn
|
func (l *DefaultLogger) Warn(msg string, args ...interface{}) error {
if l.IsWarn() {
defer l.Log(LevelWarn, msg, args)
for _, arg := range args {
if err, ok := arg.(error); ok {
return err
}
}
return nil
}
return nil
}
|
go
|
func (l *DefaultLogger) Warn(msg string, args ...interface{}) error {
if l.IsWarn() {
defer l.Log(LevelWarn, msg, args)
for _, arg := range args {
if err, ok := arg.(error); ok {
return err
}
}
return nil
}
return nil
}
|
[
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Warn",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"l",
".",
"IsWarn",
"(",
")",
"{",
"defer",
"l",
".",
"Log",
"(",
"LevelWarn",
",",
"msg",
",",
"args",
")",
"\n\n",
"for",
"_",
",",
"arg",
":=",
"range",
"args",
"{",
"if",
"err",
",",
"ok",
":=",
"arg",
".",
"(",
"error",
")",
";",
"ok",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Warn logs a warn entry.
|
[
"Warn",
"logs",
"a",
"warn",
"entry",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L74-L87
|
14,668 |
mgutz/logxi
|
v1/defaultLogger.go
|
Error
|
func (l *DefaultLogger) Error(msg string, args ...interface{}) error {
return l.extractLogError(LevelError, msg, args)
}
|
go
|
func (l *DefaultLogger) Error(msg string, args ...interface{}) error {
return l.extractLogError(LevelError, msg, args)
}
|
[
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Error",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"l",
".",
"extractLogError",
"(",
"LevelError",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] |
// Error logs an error entry.
|
[
"Error",
"logs",
"an",
"error",
"entry",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L101-L103
|
14,669 |
mgutz/logxi
|
v1/defaultLogger.go
|
Fatal
|
func (l *DefaultLogger) Fatal(msg string, args ...interface{}) {
l.extractLogError(LevelFatal, msg, args)
defer panic("Exit due to fatal error: ")
}
|
go
|
func (l *DefaultLogger) Fatal(msg string, args ...interface{}) {
l.extractLogError(LevelFatal, msg, args)
defer panic("Exit due to fatal error: ")
}
|
[
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Fatal",
"(",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"extractLogError",
"(",
"LevelFatal",
",",
"msg",
",",
"args",
")",
"\n",
"defer",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// Fatal logs a fatal entry then panics.
|
[
"Fatal",
"logs",
"a",
"fatal",
"entry",
"then",
"panics",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L106-L109
|
14,670 |
mgutz/logxi
|
v1/defaultLogger.go
|
Log
|
func (l *DefaultLogger) Log(level int, msg string, args []interface{}) {
// log if the log level (warn=4) >= level of message (err=3)
if l.level < level || silent {
return
}
l.formatter.Format(l.writer, level, msg, args)
}
|
go
|
func (l *DefaultLogger) Log(level int, msg string, args []interface{}) {
// log if the log level (warn=4) >= level of message (err=3)
if l.level < level || silent {
return
}
l.formatter.Format(l.writer, level, msg, args)
}
|
[
"func",
"(",
"l",
"*",
"DefaultLogger",
")",
"Log",
"(",
"level",
"int",
",",
"msg",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"// log if the log level (warn=4) >= level of message (err=3)",
"if",
"l",
".",
"level",
"<",
"level",
"||",
"silent",
"{",
"return",
"\n",
"}",
"\n",
"l",
".",
"formatter",
".",
"Format",
"(",
"l",
".",
"writer",
",",
"level",
",",
"msg",
",",
"args",
")",
"\n",
"}"
] |
// Log logs a leveled entry.
|
[
"Log",
"logs",
"a",
"leveled",
"entry",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/defaultLogger.go#L112-L118
|
14,671 |
mgutz/logxi
|
v1/textFormatter.go
|
NewTextFormatter
|
func NewTextFormatter(name string) *TextFormatter {
timeLabel := KeyMap.Time + AssignmentChar
levelLabel := Separator + KeyMap.Level + AssignmentChar
messageLabel := Separator + KeyMap.Message + AssignmentChar
nameLabel := Separator + KeyMap.Name + AssignmentChar
pidLabel := Separator + KeyMap.PID + AssignmentChar
var buildKV = func(level string) string {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(pidLabel)
buf.WriteString(pidStr)
//buf.WriteString(Separator)
buf.WriteString(nameLabel)
buf.WriteString(name)
//buf.WriteString(Separator)
buf.WriteString(levelLabel)
buf.WriteString(level)
//buf.WriteString(Separator)
buf.WriteString(messageLabel)
return buf.String()
}
itoaLevelMap := map[int]string{
LevelDebug: buildKV(LevelMap[LevelDebug]),
LevelWarn: buildKV(LevelMap[LevelWarn]),
LevelInfo: buildKV(LevelMap[LevelInfo]),
LevelError: buildKV(LevelMap[LevelError]),
LevelFatal: buildKV(LevelMap[LevelFatal]),
}
return &TextFormatter{itoaLevelMap: itoaLevelMap, name: name, timeLabel: timeLabel}
}
|
go
|
func NewTextFormatter(name string) *TextFormatter {
timeLabel := KeyMap.Time + AssignmentChar
levelLabel := Separator + KeyMap.Level + AssignmentChar
messageLabel := Separator + KeyMap.Message + AssignmentChar
nameLabel := Separator + KeyMap.Name + AssignmentChar
pidLabel := Separator + KeyMap.PID + AssignmentChar
var buildKV = func(level string) string {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(pidLabel)
buf.WriteString(pidStr)
//buf.WriteString(Separator)
buf.WriteString(nameLabel)
buf.WriteString(name)
//buf.WriteString(Separator)
buf.WriteString(levelLabel)
buf.WriteString(level)
//buf.WriteString(Separator)
buf.WriteString(messageLabel)
return buf.String()
}
itoaLevelMap := map[int]string{
LevelDebug: buildKV(LevelMap[LevelDebug]),
LevelWarn: buildKV(LevelMap[LevelWarn]),
LevelInfo: buildKV(LevelMap[LevelInfo]),
LevelError: buildKV(LevelMap[LevelError]),
LevelFatal: buildKV(LevelMap[LevelFatal]),
}
return &TextFormatter{itoaLevelMap: itoaLevelMap, name: name, timeLabel: timeLabel}
}
|
[
"func",
"NewTextFormatter",
"(",
"name",
"string",
")",
"*",
"TextFormatter",
"{",
"timeLabel",
":=",
"KeyMap",
".",
"Time",
"+",
"AssignmentChar",
"\n",
"levelLabel",
":=",
"Separator",
"+",
"KeyMap",
".",
"Level",
"+",
"AssignmentChar",
"\n",
"messageLabel",
":=",
"Separator",
"+",
"KeyMap",
".",
"Message",
"+",
"AssignmentChar",
"\n",
"nameLabel",
":=",
"Separator",
"+",
"KeyMap",
".",
"Name",
"+",
"AssignmentChar",
"\n",
"pidLabel",
":=",
"Separator",
"+",
"KeyMap",
".",
"PID",
"+",
"AssignmentChar",
"\n\n",
"var",
"buildKV",
"=",
"func",
"(",
"level",
"string",
")",
"string",
"{",
"buf",
":=",
"pool",
".",
"Get",
"(",
")",
"\n",
"defer",
"pool",
".",
"Put",
"(",
"buf",
")",
"\n\n",
"buf",
".",
"WriteString",
"(",
"pidLabel",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"pidStr",
")",
"\n\n",
"//buf.WriteString(Separator)",
"buf",
".",
"WriteString",
"(",
"nameLabel",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"name",
")",
"\n\n",
"//buf.WriteString(Separator)",
"buf",
".",
"WriteString",
"(",
"levelLabel",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"level",
")",
"\n\n",
"//buf.WriteString(Separator)",
"buf",
".",
"WriteString",
"(",
"messageLabel",
")",
"\n\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"itoaLevelMap",
":=",
"map",
"[",
"int",
"]",
"string",
"{",
"LevelDebug",
":",
"buildKV",
"(",
"LevelMap",
"[",
"LevelDebug",
"]",
")",
",",
"LevelWarn",
":",
"buildKV",
"(",
"LevelMap",
"[",
"LevelWarn",
"]",
")",
",",
"LevelInfo",
":",
"buildKV",
"(",
"LevelMap",
"[",
"LevelInfo",
"]",
")",
",",
"LevelError",
":",
"buildKV",
"(",
"LevelMap",
"[",
"LevelError",
"]",
")",
",",
"LevelFatal",
":",
"buildKV",
"(",
"LevelMap",
"[",
"LevelFatal",
"]",
")",
",",
"}",
"\n",
"return",
"&",
"TextFormatter",
"{",
"itoaLevelMap",
":",
"itoaLevelMap",
",",
"name",
":",
"name",
",",
"timeLabel",
":",
"timeLabel",
"}",
"\n",
"}"
] |
// NewTextFormatter returns a new instance of TextFormatter. SetName
// must be called befored using it.
|
[
"NewTextFormatter",
"returns",
"a",
"new",
"instance",
"of",
"TextFormatter",
".",
"SetName",
"must",
"be",
"called",
"befored",
"using",
"it",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/textFormatter.go#L25-L60
|
14,672 |
mgutz/logxi
|
v1/textFormatter.go
|
Format
|
func (tf *TextFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(tf.timeLabel)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(tf.itoaLevelMap[level])
buf.WriteString(msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
tf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
tf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
tf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteRune('\n')
buf.WriteTo(writer)
}
|
go
|
func (tf *TextFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(tf.timeLabel)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(tf.itoaLevelMap[level])
buf.WriteString(msg)
var lenArgs = len(args)
if lenArgs > 0 {
if lenArgs == 1 {
tf.set(buf, singleArgKey, args[0])
} else if lenArgs%2 == 0 {
for i := 0; i < lenArgs; i += 2 {
if key, ok := args[i].(string); ok {
if key == "" {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
} else {
tf.set(buf, key, args[i+1])
}
} else {
// show key is invalid
tf.set(buf, badKeyAtIndex(i), args[i+1])
}
}
} else {
tf.set(buf, warnImbalancedKey, args)
}
}
buf.WriteRune('\n')
buf.WriteTo(writer)
}
|
[
"func",
"(",
"tf",
"*",
"TextFormatter",
")",
"Format",
"(",
"writer",
"io",
".",
"Writer",
",",
"level",
"int",
",",
"msg",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"buf",
":=",
"pool",
".",
"Get",
"(",
")",
"\n",
"defer",
"pool",
".",
"Put",
"(",
"buf",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"tf",
".",
"timeLabel",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Format",
"(",
"timeFormat",
")",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"tf",
".",
"itoaLevelMap",
"[",
"level",
"]",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"msg",
")",
"\n",
"var",
"lenArgs",
"=",
"len",
"(",
"args",
")",
"\n",
"if",
"lenArgs",
">",
"0",
"{",
"if",
"lenArgs",
"==",
"1",
"{",
"tf",
".",
"set",
"(",
"buf",
",",
"singleArgKey",
",",
"args",
"[",
"0",
"]",
")",
"\n",
"}",
"else",
"if",
"lenArgs",
"%",
"2",
"==",
"0",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"lenArgs",
";",
"i",
"+=",
"2",
"{",
"if",
"key",
",",
"ok",
":=",
"args",
"[",
"i",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"if",
"key",
"==",
"\"",
"\"",
"{",
"// show key is invalid",
"tf",
".",
"set",
"(",
"buf",
",",
"badKeyAtIndex",
"(",
"i",
")",
",",
"args",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"else",
"{",
"tf",
".",
"set",
"(",
"buf",
",",
"key",
",",
"args",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// show key is invalid",
"tf",
".",
"set",
"(",
"buf",
",",
"badKeyAtIndex",
"(",
"i",
")",
",",
"args",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"tf",
".",
"set",
"(",
"buf",
",",
"warnImbalancedKey",
",",
"args",
")",
"\n",
"}",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"'\\n'",
")",
"\n",
"buf",
".",
"WriteTo",
"(",
"writer",
")",
"\n",
"}"
] |
// Format records a log entry.
|
[
"Format",
"records",
"a",
"log",
"entry",
"."
] |
aebf8a7d67ab4625e0fd4a665766fef9a709161b
|
https://github.com/mgutz/logxi/blob/aebf8a7d67ab4625e0fd4a665766fef9a709161b/v1/textFormatter.go#L76-L107
|
14,673 |
dhowden/tag
|
mp4.go
|
ReadAtoms
|
func ReadAtoms(r io.ReadSeeker) (Metadata, error) {
m := metadataMP4{
data: make(map[string]interface{}),
fileType: UnknownFileType,
}
err := m.readAtoms(r)
return m, err
}
|
go
|
func ReadAtoms(r io.ReadSeeker) (Metadata, error) {
m := metadataMP4{
data: make(map[string]interface{}),
fileType: UnknownFileType,
}
err := m.readAtoms(r)
return m, err
}
|
[
"func",
"ReadAtoms",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"Metadata",
",",
"error",
")",
"{",
"m",
":=",
"metadataMP4",
"{",
"data",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
",",
"fileType",
":",
"UnknownFileType",
",",
"}",
"\n",
"err",
":=",
"m",
".",
"readAtoms",
"(",
"r",
")",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// ReadAtoms reads MP4 metadata atoms from the io.ReadSeeker into a Metadata, returning
// non-nil error if there was a problem.
|
[
"ReadAtoms",
"reads",
"MP4",
"metadata",
"atoms",
"from",
"the",
"io",
".",
"ReadSeeker",
"into",
"a",
"Metadata",
"returning",
"non",
"-",
"nil",
"error",
"if",
"there",
"was",
"a",
"problem",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/mp4.go#L70-L77
|
14,674 |
dhowden/tag
|
sum.go
|
SumAtoms
|
func SumAtoms(r io.ReadSeeker) (string, error) {
for {
var size uint32
err := binary.Read(r, binary.BigEndian, &size)
if err != nil {
if err == io.EOF {
return "", fmt.Errorf("reached EOF before audio data")
}
return "", err
}
name, err := readString(r, 4)
if err != nil {
return "", err
}
switch name {
case "meta":
// next_item_id (int32)
_, err := r.Seek(4, io.SeekCurrent)
if err != nil {
return "", err
}
fallthrough
case "moov", "udta", "ilst":
continue
case "mdat": // stop when we get to the data
h := sha1.New()
_, err := io.CopyN(h, r, int64(size-8))
if err != nil {
return "", fmt.Errorf("error reading audio data: %v", err)
}
return hashSum(h), nil
}
_, err = r.Seek(int64(size-8), io.SeekCurrent)
if err != nil {
return "", fmt.Errorf("error reading '%v' tag: %v", name, err)
}
}
}
|
go
|
func SumAtoms(r io.ReadSeeker) (string, error) {
for {
var size uint32
err := binary.Read(r, binary.BigEndian, &size)
if err != nil {
if err == io.EOF {
return "", fmt.Errorf("reached EOF before audio data")
}
return "", err
}
name, err := readString(r, 4)
if err != nil {
return "", err
}
switch name {
case "meta":
// next_item_id (int32)
_, err := r.Seek(4, io.SeekCurrent)
if err != nil {
return "", err
}
fallthrough
case "moov", "udta", "ilst":
continue
case "mdat": // stop when we get to the data
h := sha1.New()
_, err := io.CopyN(h, r, int64(size-8))
if err != nil {
return "", fmt.Errorf("error reading audio data: %v", err)
}
return hashSum(h), nil
}
_, err = r.Seek(int64(size-8), io.SeekCurrent)
if err != nil {
return "", fmt.Errorf("error reading '%v' tag: %v", name, err)
}
}
}
|
[
"func",
"SumAtoms",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"string",
",",
"error",
")",
"{",
"for",
"{",
"var",
"size",
"uint32",
"\n",
"err",
":=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"BigEndian",
",",
"&",
"size",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"name",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"4",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"name",
"{",
"case",
"\"",
"\"",
":",
"// next_item_id (int32)",
"_",
",",
"err",
":=",
"r",
".",
"Seek",
"(",
"4",
",",
"io",
".",
"SeekCurrent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"fallthrough",
"\n\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"continue",
"\n\n",
"case",
"\"",
"\"",
":",
"// stop when we get to the data",
"h",
":=",
"sha1",
".",
"New",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"CopyN",
"(",
"h",
",",
"r",
",",
"int64",
"(",
"size",
"-",
"8",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"hashSum",
"(",
"h",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"r",
".",
"Seek",
"(",
"int64",
"(",
"size",
"-",
"8",
")",
",",
"io",
".",
"SeekCurrent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// SumAtoms constructs a checksum of MP4 audio file data provided by the io.ReadSeeker which is
// metadata invariant.
|
[
"SumAtoms",
"constructs",
"a",
"checksum",
"of",
"MP4",
"audio",
"file",
"data",
"provided",
"by",
"the",
"io",
".",
"ReadSeeker",
"which",
"is",
"metadata",
"invariant",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/sum.go#L58-L100
|
14,675 |
dhowden/tag
|
id3v2frames.go
|
String
|
func (t Comm) String() string {
if t.Language != "" {
return fmt.Sprintf("Text{Lang: '%v', Description: '%v', %v lines}",
t.Language, t.Description, strings.Count(t.Text, "\n"))
}
return fmt.Sprintf("Text{Description: '%v', %v}", t.Description, t.Text)
}
|
go
|
func (t Comm) String() string {
if t.Language != "" {
return fmt.Sprintf("Text{Lang: '%v', Description: '%v', %v lines}",
t.Language, t.Description, strings.Count(t.Text, "\n"))
}
return fmt.Sprintf("Text{Description: '%v', %v}", t.Description, t.Text)
}
|
[
"func",
"(",
"t",
"Comm",
")",
"String",
"(",
")",
"string",
"{",
"if",
"t",
".",
"Language",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Language",
",",
"t",
".",
"Description",
",",
"strings",
".",
"Count",
"(",
"t",
".",
"Text",
",",
"\"",
"\\n",
"\"",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Description",
",",
"t",
".",
"Text",
")",
"\n",
"}"
] |
// String returns a string representation of the underlying Comm instance.
|
[
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"underlying",
"Comm",
"instance",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2frames.go#L430-L436
|
14,676 |
dhowden/tag
|
id3v2frames.go
|
String
|
func (p Picture) String() string {
return fmt.Sprintf("Picture{Ext: %v, MIMEType: %v, Type: %v, Description: %v, Data.Size: %v}",
p.Ext, p.MIMEType, p.Type, p.Description, len(p.Data))
}
|
go
|
func (p Picture) String() string {
return fmt.Sprintf("Picture{Ext: %v, MIMEType: %v, Type: %v, Description: %v, Data.Size: %v}",
p.Ext, p.MIMEType, p.Type, p.Description, len(p.Data))
}
|
[
"func",
"(",
"p",
"Picture",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"Ext",
",",
"p",
".",
"MIMEType",
",",
"p",
".",
"Type",
",",
"p",
".",
"Description",
",",
"len",
"(",
"p",
".",
"Data",
")",
")",
"\n",
"}"
] |
// String returns a string representation of the underlying Picture instance.
|
[
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"underlying",
"Picture",
"instance",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2frames.go#L548-L551
|
14,677 |
dhowden/tag
|
id3v1.go
|
ReadID3v1Tags
|
func ReadID3v1Tags(r io.ReadSeeker) (Metadata, error) {
_, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return nil, err
}
if tag, err := readString(r, 3); err != nil {
return nil, err
} else if tag != "TAG" {
return nil, ErrNotID3v1
}
title, err := readString(r, 30)
if err != nil {
return nil, err
}
artist, err := readString(r, 30)
if err != nil {
return nil, err
}
album, err := readString(r, 30)
if err != nil {
return nil, err
}
year, err := readString(r, 4)
if err != nil {
return nil, err
}
commentBytes, err := readBytes(r, 30)
if err != nil {
return nil, err
}
var comment string
var track int
if commentBytes[28] == 0 {
comment = trimString(string(commentBytes[:28]))
track = int(commentBytes[29])
} else {
comment = trimString(string(commentBytes))
}
var genre string
genreID, err := readBytes(r, 1)
if err != nil {
return nil, err
}
if int(genreID[0]) < len(id3v1Genres) {
genre = id3v1Genres[int(genreID[0])]
}
m := make(map[string]interface{})
m["title"] = trimString(title)
m["artist"] = trimString(artist)
m["album"] = trimString(album)
m["year"] = trimString(year)
m["comment"] = trimString(comment)
m["track"] = track
m["genre"] = genre
return metadataID3v1(m), nil
}
|
go
|
func ReadID3v1Tags(r io.ReadSeeker) (Metadata, error) {
_, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return nil, err
}
if tag, err := readString(r, 3); err != nil {
return nil, err
} else if tag != "TAG" {
return nil, ErrNotID3v1
}
title, err := readString(r, 30)
if err != nil {
return nil, err
}
artist, err := readString(r, 30)
if err != nil {
return nil, err
}
album, err := readString(r, 30)
if err != nil {
return nil, err
}
year, err := readString(r, 4)
if err != nil {
return nil, err
}
commentBytes, err := readBytes(r, 30)
if err != nil {
return nil, err
}
var comment string
var track int
if commentBytes[28] == 0 {
comment = trimString(string(commentBytes[:28]))
track = int(commentBytes[29])
} else {
comment = trimString(string(commentBytes))
}
var genre string
genreID, err := readBytes(r, 1)
if err != nil {
return nil, err
}
if int(genreID[0]) < len(id3v1Genres) {
genre = id3v1Genres[int(genreID[0])]
}
m := make(map[string]interface{})
m["title"] = trimString(title)
m["artist"] = trimString(artist)
m["album"] = trimString(album)
m["year"] = trimString(year)
m["comment"] = trimString(comment)
m["track"] = track
m["genre"] = genre
return metadataID3v1(m), nil
}
|
[
"func",
"ReadID3v1Tags",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"Metadata",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"r",
".",
"Seek",
"(",
"-",
"128",
",",
"io",
".",
"SeekEnd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"tag",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"3",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"tag",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrNotID3v1",
"\n",
"}",
"\n\n",
"title",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"30",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"artist",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"30",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"album",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"30",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"year",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"4",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"commentBytes",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"30",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"comment",
"string",
"\n",
"var",
"track",
"int",
"\n",
"if",
"commentBytes",
"[",
"28",
"]",
"==",
"0",
"{",
"comment",
"=",
"trimString",
"(",
"string",
"(",
"commentBytes",
"[",
":",
"28",
"]",
")",
")",
"\n",
"track",
"=",
"int",
"(",
"commentBytes",
"[",
"29",
"]",
")",
"\n",
"}",
"else",
"{",
"comment",
"=",
"trimString",
"(",
"string",
"(",
"commentBytes",
")",
")",
"\n",
"}",
"\n\n",
"var",
"genre",
"string",
"\n",
"genreID",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"int",
"(",
"genreID",
"[",
"0",
"]",
")",
"<",
"len",
"(",
"id3v1Genres",
")",
"{",
"genre",
"=",
"id3v1Genres",
"[",
"int",
"(",
"genreID",
"[",
"0",
"]",
")",
"]",
"\n",
"}",
"\n\n",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"trimString",
"(",
"title",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"trimString",
"(",
"artist",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"trimString",
"(",
"album",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"trimString",
"(",
"year",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"trimString",
"(",
"comment",
")",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"track",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"genre",
"\n\n",
"return",
"metadataID3v1",
"(",
"m",
")",
",",
"nil",
"\n",
"}"
] |
// ReadID3v1Tags reads ID3v1 tags from the io.ReadSeeker. Returns ErrNotID3v1
// if there are no ID3v1 tags, otherwise non-nil error if there was a problem.
|
[
"ReadID3v1Tags",
"reads",
"ID3v1",
"tags",
"from",
"the",
"io",
".",
"ReadSeeker",
".",
"Returns",
"ErrNotID3v1",
"if",
"there",
"are",
"no",
"ID3v1",
"tags",
"otherwise",
"non",
"-",
"nil",
"error",
"if",
"there",
"was",
"a",
"problem",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v1.go#L45-L110
|
14,678 |
dhowden/tag
|
id.go
|
Identify
|
func Identify(r io.ReadSeeker) (format Format, fileType FileType, err error) {
b, err := readBytes(r, 11)
if err != nil {
return
}
_, err = r.Seek(-11, io.SeekCurrent)
if err != nil {
err = fmt.Errorf("could not seek back to original position: %v", err)
return
}
switch {
case string(b[0:4]) == "fLaC":
return VORBIS, FLAC, nil
case string(b[0:4]) == "OggS":
return VORBIS, OGG, nil
case string(b[4:8]) == "ftyp":
b = b[8:11]
fileType = UnknownFileType
switch string(b) {
case "M4A":
fileType = M4A
case "M4B":
fileType = M4B
case "M4P":
fileType = M4P
}
return MP4, fileType, nil
case string(b[0:3]) == "ID3":
b := b[3:]
switch uint(b[0]) {
case 2:
format = ID3v2_2
case 3:
format = ID3v2_3
case 4:
format = ID3v2_4
case 0, 1:
fallthrough
default:
err = fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
return
}
return format, MP3, nil
}
n, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return
}
tag, err := readString(r, 3)
if err != nil {
return
}
_, err = r.Seek(-n, io.SeekCurrent)
if err != nil {
return
}
if tag != "TAG" {
err = ErrNoTagsFound
return
}
return ID3v1, MP3, nil
}
|
go
|
func Identify(r io.ReadSeeker) (format Format, fileType FileType, err error) {
b, err := readBytes(r, 11)
if err != nil {
return
}
_, err = r.Seek(-11, io.SeekCurrent)
if err != nil {
err = fmt.Errorf("could not seek back to original position: %v", err)
return
}
switch {
case string(b[0:4]) == "fLaC":
return VORBIS, FLAC, nil
case string(b[0:4]) == "OggS":
return VORBIS, OGG, nil
case string(b[4:8]) == "ftyp":
b = b[8:11]
fileType = UnknownFileType
switch string(b) {
case "M4A":
fileType = M4A
case "M4B":
fileType = M4B
case "M4P":
fileType = M4P
}
return MP4, fileType, nil
case string(b[0:3]) == "ID3":
b := b[3:]
switch uint(b[0]) {
case 2:
format = ID3v2_2
case 3:
format = ID3v2_3
case 4:
format = ID3v2_4
case 0, 1:
fallthrough
default:
err = fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
return
}
return format, MP3, nil
}
n, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return
}
tag, err := readString(r, 3)
if err != nil {
return
}
_, err = r.Seek(-n, io.SeekCurrent)
if err != nil {
return
}
if tag != "TAG" {
err = ErrNoTagsFound
return
}
return ID3v1, MP3, nil
}
|
[
"func",
"Identify",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"format",
"Format",
",",
"fileType",
"FileType",
",",
"err",
"error",
")",
"{",
"b",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"11",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"r",
".",
"Seek",
"(",
"-",
"11",
",",
"io",
".",
"SeekCurrent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"switch",
"{",
"case",
"string",
"(",
"b",
"[",
"0",
":",
"4",
"]",
")",
"==",
"\"",
"\"",
":",
"return",
"VORBIS",
",",
"FLAC",
",",
"nil",
"\n\n",
"case",
"string",
"(",
"b",
"[",
"0",
":",
"4",
"]",
")",
"==",
"\"",
"\"",
":",
"return",
"VORBIS",
",",
"OGG",
",",
"nil",
"\n\n",
"case",
"string",
"(",
"b",
"[",
"4",
":",
"8",
"]",
")",
"==",
"\"",
"\"",
":",
"b",
"=",
"b",
"[",
"8",
":",
"11",
"]",
"\n",
"fileType",
"=",
"UnknownFileType",
"\n",
"switch",
"string",
"(",
"b",
")",
"{",
"case",
"\"",
"\"",
":",
"fileType",
"=",
"M4A",
"\n\n",
"case",
"\"",
"\"",
":",
"fileType",
"=",
"M4B",
"\n\n",
"case",
"\"",
"\"",
":",
"fileType",
"=",
"M4P",
"\n",
"}",
"\n",
"return",
"MP4",
",",
"fileType",
",",
"nil",
"\n\n",
"case",
"string",
"(",
"b",
"[",
"0",
":",
"3",
"]",
")",
"==",
"\"",
"\"",
":",
"b",
":=",
"b",
"[",
"3",
":",
"]",
"\n",
"switch",
"uint",
"(",
"b",
"[",
"0",
"]",
")",
"{",
"case",
"2",
":",
"format",
"=",
"ID3v2_2",
"\n",
"case",
"3",
":",
"format",
"=",
"ID3v2_3",
"\n",
"case",
"4",
":",
"format",
"=",
"ID3v2_4",
"\n",
"case",
"0",
",",
"1",
":",
"fallthrough",
"\n",
"default",
":",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"uint",
"(",
"b",
"[",
"0",
"]",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"return",
"format",
",",
"MP3",
",",
"nil",
"\n",
"}",
"\n\n",
"n",
",",
"err",
":=",
"r",
".",
"Seek",
"(",
"-",
"128",
",",
"io",
".",
"SeekEnd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"tag",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"3",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"r",
".",
"Seek",
"(",
"-",
"n",
",",
"io",
".",
"SeekCurrent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"tag",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"ErrNoTagsFound",
"\n",
"return",
"\n",
"}",
"\n",
"return",
"ID3v1",
",",
"MP3",
",",
"nil",
"\n",
"}"
] |
// Identify identifies the format and file type of the data in the ReadSeeker.
|
[
"Identify",
"identifies",
"the",
"format",
"and",
"file",
"type",
"of",
"the",
"data",
"in",
"the",
"ReadSeeker",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id.go#L9-L81
|
14,679 |
dhowden/tag
|
id3v2.go
|
readID3v2Header
|
func readID3v2Header(r io.Reader) (h *id3v2Header, offset int, err error) {
offset = 10
b, err := readBytes(r, offset)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 10 bytes (ID3v2Header): %v", err)
}
if string(b[0:3]) != "ID3" {
return nil, 0, fmt.Errorf("expected to read \"ID3\"")
}
b = b[3:]
var vers Format
switch uint(b[0]) {
case 2:
vers = ID3v2_2
case 3:
vers = ID3v2_3
case 4:
vers = ID3v2_4
case 0, 1:
fallthrough
default:
return nil, 0, fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
}
// NB: We ignore b[1] (the revision) as we don't currently rely on it.
h = &id3v2Header{
Version: vers,
Unsynchronisation: getBit(b[2], 7),
ExtendedHeader: getBit(b[2], 6),
Experimental: getBit(b[2], 5),
Size: get7BitChunkedInt(b[3:7]),
}
if h.ExtendedHeader {
switch vers {
case ID3v2_3:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v23 extended header len): %v", err)
}
// skip header, size is excluding len bytes
extendedHeaderSize := getInt(b)
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v23 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
case ID3v2_4:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v24 extended header len): %v", err)
}
// skip header, size is synchsafe int including len bytes
extendedHeaderSize := get7BitChunkedInt(b) - 4
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v24 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
default:
// nop, only 2.3 and 2.4 should have extended header
}
}
return h, offset, nil
}
|
go
|
func readID3v2Header(r io.Reader) (h *id3v2Header, offset int, err error) {
offset = 10
b, err := readBytes(r, offset)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 10 bytes (ID3v2Header): %v", err)
}
if string(b[0:3]) != "ID3" {
return nil, 0, fmt.Errorf("expected to read \"ID3\"")
}
b = b[3:]
var vers Format
switch uint(b[0]) {
case 2:
vers = ID3v2_2
case 3:
vers = ID3v2_3
case 4:
vers = ID3v2_4
case 0, 1:
fallthrough
default:
return nil, 0, fmt.Errorf("ID3 version: %v, expected: 2, 3 or 4", uint(b[0]))
}
// NB: We ignore b[1] (the revision) as we don't currently rely on it.
h = &id3v2Header{
Version: vers,
Unsynchronisation: getBit(b[2], 7),
ExtendedHeader: getBit(b[2], 6),
Experimental: getBit(b[2], 5),
Size: get7BitChunkedInt(b[3:7]),
}
if h.ExtendedHeader {
switch vers {
case ID3v2_3:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v23 extended header len): %v", err)
}
// skip header, size is excluding len bytes
extendedHeaderSize := getInt(b)
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v23 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
case ID3v2_4:
b, err := readBytes(r, 4)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 4 bytes (ID3v24 extended header len): %v", err)
}
// skip header, size is synchsafe int including len bytes
extendedHeaderSize := get7BitChunkedInt(b) - 4
_, err = readBytes(r, extendedHeaderSize)
if err != nil {
return nil, 0, fmt.Errorf("expected to read %d bytes (ID3v24 skip extended header): %v", extendedHeaderSize, err)
}
offset += extendedHeaderSize
default:
// nop, only 2.3 and 2.4 should have extended header
}
}
return h, offset, nil
}
|
[
"func",
"readID3v2Header",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"h",
"*",
"id3v2Header",
",",
"offset",
"int",
",",
"err",
"error",
")",
"{",
"offset",
"=",
"10",
"\n",
"b",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"offset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"string",
"(",
"b",
"[",
"0",
":",
"3",
"]",
")",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
")",
"\n",
"}",
"\n\n",
"b",
"=",
"b",
"[",
"3",
":",
"]",
"\n",
"var",
"vers",
"Format",
"\n",
"switch",
"uint",
"(",
"b",
"[",
"0",
"]",
")",
"{",
"case",
"2",
":",
"vers",
"=",
"ID3v2_2",
"\n",
"case",
"3",
":",
"vers",
"=",
"ID3v2_3",
"\n",
"case",
"4",
":",
"vers",
"=",
"ID3v2_4",
"\n",
"case",
"0",
",",
"1",
":",
"fallthrough",
"\n",
"default",
":",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"uint",
"(",
"b",
"[",
"0",
"]",
")",
")",
"\n",
"}",
"\n\n",
"// NB: We ignore b[1] (the revision) as we don't currently rely on it.",
"h",
"=",
"&",
"id3v2Header",
"{",
"Version",
":",
"vers",
",",
"Unsynchronisation",
":",
"getBit",
"(",
"b",
"[",
"2",
"]",
",",
"7",
")",
",",
"ExtendedHeader",
":",
"getBit",
"(",
"b",
"[",
"2",
"]",
",",
"6",
")",
",",
"Experimental",
":",
"getBit",
"(",
"b",
"[",
"2",
"]",
",",
"5",
")",
",",
"Size",
":",
"get7BitChunkedInt",
"(",
"b",
"[",
"3",
":",
"7",
"]",
")",
",",
"}",
"\n\n",
"if",
"h",
".",
"ExtendedHeader",
"{",
"switch",
"vers",
"{",
"case",
"ID3v2_3",
":",
"b",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"4",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"// skip header, size is excluding len bytes",
"extendedHeaderSize",
":=",
"getInt",
"(",
"b",
")",
"\n",
"_",
",",
"err",
"=",
"readBytes",
"(",
"r",
",",
"extendedHeaderSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"extendedHeaderSize",
",",
"err",
")",
"\n",
"}",
"\n",
"offset",
"+=",
"extendedHeaderSize",
"\n",
"case",
"ID3v2_4",
":",
"b",
",",
"err",
":=",
"readBytes",
"(",
"r",
",",
"4",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"// skip header, size is synchsafe int including len bytes",
"extendedHeaderSize",
":=",
"get7BitChunkedInt",
"(",
"b",
")",
"-",
"4",
"\n",
"_",
",",
"err",
"=",
"readBytes",
"(",
"r",
",",
"extendedHeaderSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"extendedHeaderSize",
",",
"err",
")",
"\n",
"}",
"\n",
"offset",
"+=",
"extendedHeaderSize",
"\n",
"default",
":",
"// nop, only 2.3 and 2.4 should have extended header",
"}",
"\n",
"}",
"\n\n",
"return",
"h",
",",
"offset",
",",
"nil",
"\n",
"}"
] |
// readID3v2Header reads the ID3v2 header from the given io.Reader.
// offset it number of bytes of header that was read
|
[
"readID3v2Header",
"reads",
"the",
"ID3v2",
"header",
"from",
"the",
"given",
"io",
".",
"Reader",
".",
"offset",
"it",
"number",
"of",
"bytes",
"of",
"header",
"that",
"was",
"read"
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2.go#L56-L123
|
14,680 |
dhowden/tag
|
id3v2.go
|
Read
|
func (r *unsynchroniser) Read(p []byte) (int, error) {
b := make([]byte, 1)
i := 0
for i < len(p) {
if n, err := r.Reader.Read(b); err != nil || n == 0 {
return i, err
}
if r.ff && b[0] == 0x00 {
r.ff = false
continue
}
p[i] = b[0]
i++
r.ff = (b[0] == 0xFF)
}
return i, nil
}
|
go
|
func (r *unsynchroniser) Read(p []byte) (int, error) {
b := make([]byte, 1)
i := 0
for i < len(p) {
if n, err := r.Reader.Read(b); err != nil || n == 0 {
return i, err
}
if r.ff && b[0] == 0x00 {
r.ff = false
continue
}
p[i] = b[0]
i++
r.ff = (b[0] == 0xFF)
}
return i, nil
}
|
[
"func",
"(",
"r",
"*",
"unsynchroniser",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"i",
":=",
"0",
"\n",
"for",
"i",
"<",
"len",
"(",
"p",
")",
"{",
"if",
"n",
",",
"err",
":=",
"r",
".",
"Reader",
".",
"Read",
"(",
"b",
")",
";",
"err",
"!=",
"nil",
"||",
"n",
"==",
"0",
"{",
"return",
"i",
",",
"err",
"\n",
"}",
"\n",
"if",
"r",
".",
"ff",
"&&",
"b",
"[",
"0",
"]",
"==",
"0x00",
"{",
"r",
".",
"ff",
"=",
"false",
"\n",
"continue",
"\n",
"}",
"\n",
"p",
"[",
"i",
"]",
"=",
"b",
"[",
"0",
"]",
"\n",
"i",
"++",
"\n",
"r",
".",
"ff",
"=",
"(",
"b",
"[",
"0",
"]",
"==",
"0xFF",
")",
"\n",
"}",
"\n",
"return",
"i",
",",
"nil",
"\n",
"}"
] |
// filter io.Reader which skip the Unsynchronisation bytes
|
[
"filter",
"io",
".",
"Reader",
"which",
"skip",
"the",
"Unsynchronisation",
"bytes"
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2.go#L373-L389
|
14,681 |
dhowden/tag
|
id3v2.go
|
id3v2genre
|
func id3v2genre(genre string) string {
c := true
for c {
orig := genre
if match := id3v2genreRe.FindStringSubmatch(genre); len(match) > 0 {
if genreID, err := strconv.Atoi(match[2]); err == nil {
if genreID < len(id3v2Genres) {
genre = id3v2Genres[genreID]
if match[1] != "" {
genre = strings.TrimSpace(match[1]) + " " + genre
}
if match[3] != "" {
genre = genre + " " + match[3]
}
}
}
}
c = (orig != genre)
}
return strings.Replace(genre, "((", "(", -1)
}
|
go
|
func id3v2genre(genre string) string {
c := true
for c {
orig := genre
if match := id3v2genreRe.FindStringSubmatch(genre); len(match) > 0 {
if genreID, err := strconv.Atoi(match[2]); err == nil {
if genreID < len(id3v2Genres) {
genre = id3v2Genres[genreID]
if match[1] != "" {
genre = strings.TrimSpace(match[1]) + " " + genre
}
if match[3] != "" {
genre = genre + " " + match[3]
}
}
}
}
c = (orig != genre)
}
return strings.Replace(genre, "((", "(", -1)
}
|
[
"func",
"id3v2genre",
"(",
"genre",
"string",
")",
"string",
"{",
"c",
":=",
"true",
"\n",
"for",
"c",
"{",
"orig",
":=",
"genre",
"\n",
"if",
"match",
":=",
"id3v2genreRe",
".",
"FindStringSubmatch",
"(",
"genre",
")",
";",
"len",
"(",
"match",
")",
">",
"0",
"{",
"if",
"genreID",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"match",
"[",
"2",
"]",
")",
";",
"err",
"==",
"nil",
"{",
"if",
"genreID",
"<",
"len",
"(",
"id3v2Genres",
")",
"{",
"genre",
"=",
"id3v2Genres",
"[",
"genreID",
"]",
"\n",
"if",
"match",
"[",
"1",
"]",
"!=",
"\"",
"\"",
"{",
"genre",
"=",
"strings",
".",
"TrimSpace",
"(",
"match",
"[",
"1",
"]",
")",
"+",
"\"",
"\"",
"+",
"genre",
"\n",
"}",
"\n",
"if",
"match",
"[",
"3",
"]",
"!=",
"\"",
"\"",
"{",
"genre",
"=",
"genre",
"+",
"\"",
"\"",
"+",
"match",
"[",
"3",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"c",
"=",
"(",
"orig",
"!=",
"genre",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Replace",
"(",
"genre",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"}"
] |
// id3v2genre parse a id3v2 genre tag and expand the numeric genres
|
[
"id3v2genre",
"parse",
"a",
"id3v2",
"genre",
"tag",
"and",
"expand",
"the",
"numeric",
"genres"
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/id3v2.go#L414-L434
|
14,682 |
dhowden/tag
|
flac.go
|
ReadFLACTags
|
func ReadFLACTags(r io.ReadSeeker) (Metadata, error) {
flac, err := readString(r, 4)
if err != nil {
return nil, err
}
if flac != "fLaC" {
return nil, errors.New("expected 'fLaC'")
}
m := &metadataFLAC{
newMetadataVorbis(),
}
for {
last, err := m.readFLACMetadataBlock(r)
if err != nil {
return nil, err
}
if last {
break
}
}
return m, nil
}
|
go
|
func ReadFLACTags(r io.ReadSeeker) (Metadata, error) {
flac, err := readString(r, 4)
if err != nil {
return nil, err
}
if flac != "fLaC" {
return nil, errors.New("expected 'fLaC'")
}
m := &metadataFLAC{
newMetadataVorbis(),
}
for {
last, err := m.readFLACMetadataBlock(r)
if err != nil {
return nil, err
}
if last {
break
}
}
return m, nil
}
|
[
"func",
"ReadFLACTags",
"(",
"r",
"io",
".",
"ReadSeeker",
")",
"(",
"Metadata",
",",
"error",
")",
"{",
"flac",
",",
"err",
":=",
"readString",
"(",
"r",
",",
"4",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"flac",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"metadataFLAC",
"{",
"newMetadataVorbis",
"(",
")",
",",
"}",
"\n\n",
"for",
"{",
"last",
",",
"err",
":=",
"m",
".",
"readFLACMetadataBlock",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"last",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// ReadFLACTags reads FLAC metadata from the io.ReadSeeker, returning the resulting
// metadata in a Metadata implementation, or non-nil error if there was a problem.
|
[
"ReadFLACTags",
"reads",
"FLAC",
"metadata",
"from",
"the",
"io",
".",
"ReadSeeker",
"returning",
"the",
"resulting",
"metadata",
"in",
"a",
"Metadata",
"implementation",
"or",
"non",
"-",
"nil",
"error",
"if",
"there",
"was",
"a",
"problem",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/flac.go#L28-L52
|
14,683 |
dhowden/tag
|
mbz/mbz.go
|
set
|
func (i Info) set(t, v string) {
if _, ok := tags[t]; ok {
i[t] = v
return
}
for k, tt := range tags {
if tt == t {
i[k] = v
return
}
}
}
|
go
|
func (i Info) set(t, v string) {
if _, ok := tags[t]; ok {
i[t] = v
return
}
for k, tt := range tags {
if tt == t {
i[k] = v
return
}
}
}
|
[
"func",
"(",
"i",
"Info",
")",
"set",
"(",
"t",
",",
"v",
"string",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"tags",
"[",
"t",
"]",
";",
"ok",
"{",
"i",
"[",
"t",
"]",
"=",
"v",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"tt",
":=",
"range",
"tags",
"{",
"if",
"tt",
"==",
"t",
"{",
"i",
"[",
"k",
"]",
"=",
"v",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// set the MusicBrainz tag to the given value.
|
[
"set",
"the",
"MusicBrainz",
"tag",
"to",
"the",
"given",
"value",
"."
] |
a9f04c2798caa184ec116ff25e9a1a15e9b3f79a
|
https://github.com/dhowden/tag/blob/a9f04c2798caa184ec116ff25e9a1a15e9b3f79a/mbz/mbz.go#L51-L63
|
14,684 |
kolide/osquery-go
|
plugin/logger/logger.go
|
NewPlugin
|
func NewPlugin(name string, fn LogFunc) *Plugin {
return &Plugin{name: name, logFn: fn}
}
|
go
|
func NewPlugin(name string, fn LogFunc) *Plugin {
return &Plugin{name: name, logFn: fn}
}
|
[
"func",
"NewPlugin",
"(",
"name",
"string",
",",
"fn",
"LogFunc",
")",
"*",
"Plugin",
"{",
"return",
"&",
"Plugin",
"{",
"name",
":",
"name",
",",
"logFn",
":",
"fn",
"}",
"\n",
"}"
] |
// NewPlugin takes a value that implements LoggerPlugin and wraps it with
// the appropriate methods to satisfy the OsqueryPlugin interface. Use this to
// easily create plugins implementing osquery loggers.
|
[
"NewPlugin",
"takes",
"a",
"value",
"that",
"implements",
"LoggerPlugin",
"and",
"wraps",
"it",
"with",
"the",
"appropriate",
"methods",
"to",
"satisfy",
"the",
"OsqueryPlugin",
"interface",
".",
"Use",
"this",
"to",
"easily",
"create",
"plugins",
"implementing",
"osquery",
"loggers",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/logger/logger.go#L32-L34
|
14,685 |
kolide/osquery-go
|
plugin/logger/logger.go
|
String
|
func (l LogType) String() string {
var typeString string
switch l {
case LogTypeString:
typeString = "string"
case LogTypeSnapshot:
typeString = "snapshot"
case LogTypeHealth:
typeString = "health"
case LogTypeInit:
typeString = "init"
case LogTypeStatus:
typeString = "status"
default:
typeString = "unknown"
}
return typeString
}
|
go
|
func (l LogType) String() string {
var typeString string
switch l {
case LogTypeString:
typeString = "string"
case LogTypeSnapshot:
typeString = "snapshot"
case LogTypeHealth:
typeString = "health"
case LogTypeInit:
typeString = "init"
case LogTypeStatus:
typeString = "status"
default:
typeString = "unknown"
}
return typeString
}
|
[
"func",
"(",
"l",
"LogType",
")",
"String",
"(",
")",
"string",
"{",
"var",
"typeString",
"string",
"\n",
"switch",
"l",
"{",
"case",
"LogTypeString",
":",
"typeString",
"=",
"\"",
"\"",
"\n",
"case",
"LogTypeSnapshot",
":",
"typeString",
"=",
"\"",
"\"",
"\n",
"case",
"LogTypeHealth",
":",
"typeString",
"=",
"\"",
"\"",
"\n",
"case",
"LogTypeInit",
":",
"typeString",
"=",
"\"",
"\"",
"\n",
"case",
"LogTypeStatus",
":",
"typeString",
"=",
"\"",
"\"",
"\n",
"default",
":",
"typeString",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"typeString",
"\n",
"}"
] |
// String implements the fmt.Stringer interface for LogType.
|
[
"String",
"implements",
"the",
"fmt",
".",
"Stringer",
"interface",
"for",
"LogType",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/logger/logger.go#L129-L146
|
14,686 |
kolide/osquery-go
|
transport/transport_windows.go
|
Open
|
func Open(path string, timeout time.Duration) (*thrift.TSocket, error) {
conn, err := winio.DialPipe(path, &timeout)
if err != nil {
return nil, errors.Wrapf(err, "dialing pipe '%s'", path)
}
return thrift.NewTSocketFromConnTimeout(conn, timeout), nil
}
|
go
|
func Open(path string, timeout time.Duration) (*thrift.TSocket, error) {
conn, err := winio.DialPipe(path, &timeout)
if err != nil {
return nil, errors.Wrapf(err, "dialing pipe '%s'", path)
}
return thrift.NewTSocketFromConnTimeout(conn, timeout), nil
}
|
[
"func",
"Open",
"(",
"path",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"thrift",
".",
"TSocket",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"winio",
".",
"DialPipe",
"(",
"path",
",",
"&",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"path",
")",
"\n",
"}",
"\n",
"return",
"thrift",
".",
"NewTSocketFromConnTimeout",
"(",
"conn",
",",
"timeout",
")",
",",
"nil",
"\n",
"}"
] |
// Open opens the named pipe with the provided path and timeout,
// returning a TTransport.
|
[
"Open",
"opens",
"the",
"named",
"pipe",
"with",
"the",
"provided",
"path",
"and",
"timeout",
"returning",
"a",
"TTransport",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/transport/transport_windows.go#L16-L22
|
14,687 |
kolide/osquery-go
|
transport/transport_windows.go
|
Accept
|
func (p *TServerPipe) Accept() (thrift.TTransport, error) {
p.mu.RLock()
interrupted := p.interrupted
listener := p.listener
p.mu.RUnlock()
if interrupted {
return nil, errors.New("transport interrupted")
}
conn, err := listener.Accept()
if err != nil {
return nil, thrift.NewTTransportExceptionFromError(err)
}
return thrift.NewTSocketFromConnTimeout(conn, p.clientTimeout), nil
}
|
go
|
func (p *TServerPipe) Accept() (thrift.TTransport, error) {
p.mu.RLock()
interrupted := p.interrupted
listener := p.listener
p.mu.RUnlock()
if interrupted {
return nil, errors.New("transport interrupted")
}
conn, err := listener.Accept()
if err != nil {
return nil, thrift.NewTTransportExceptionFromError(err)
}
return thrift.NewTSocketFromConnTimeout(conn, p.clientTimeout), nil
}
|
[
"func",
"(",
"p",
"*",
"TServerPipe",
")",
"Accept",
"(",
")",
"(",
"thrift",
".",
"TTransport",
",",
"error",
")",
"{",
"p",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"interrupted",
":=",
"p",
".",
"interrupted",
"\n",
"listener",
":=",
"p",
".",
"listener",
"\n",
"p",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"interrupted",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"listener",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"thrift",
".",
"NewTTransportExceptionFromError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"thrift",
".",
"NewTSocketFromConnTimeout",
"(",
"conn",
",",
"p",
".",
"clientTimeout",
")",
",",
"nil",
"\n",
"}"
] |
// Accept wraps the standard net.Listener accept to return a thrift.TTransport.
|
[
"Accept",
"wraps",
"the",
"standard",
"net",
".",
"Listener",
"accept",
"to",
"return",
"a",
"thrift",
".",
"TTransport",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/transport/transport_windows.go#L66-L81
|
14,688 |
kolide/osquery-go
|
server.go
|
NewExtensionManagerServer
|
func NewExtensionManagerServer(name string, sockPath string, opts ...ServerOption) (*ExtensionManagerServer, error) {
// Initialize nested registry maps
registry := make(map[string](map[string]OsqueryPlugin))
for reg, _ := range validRegistryNames {
registry[reg] = make(map[string]OsqueryPlugin)
}
manager := &ExtensionManagerServer{
name: name,
sockPath: sockPath,
registry: registry,
timeout: defaultTimeout,
pingInterval: defaultPingInterval,
}
for _, opt := range opts {
opt(manager)
}
serverClient, err := NewClient(sockPath, manager.timeout)
if err != nil {
return nil, err
}
manager.serverClient = serverClient
return manager, nil
}
|
go
|
func NewExtensionManagerServer(name string, sockPath string, opts ...ServerOption) (*ExtensionManagerServer, error) {
// Initialize nested registry maps
registry := make(map[string](map[string]OsqueryPlugin))
for reg, _ := range validRegistryNames {
registry[reg] = make(map[string]OsqueryPlugin)
}
manager := &ExtensionManagerServer{
name: name,
sockPath: sockPath,
registry: registry,
timeout: defaultTimeout,
pingInterval: defaultPingInterval,
}
for _, opt := range opts {
opt(manager)
}
serverClient, err := NewClient(sockPath, manager.timeout)
if err != nil {
return nil, err
}
manager.serverClient = serverClient
return manager, nil
}
|
[
"func",
"NewExtensionManagerServer",
"(",
"name",
"string",
",",
"sockPath",
"string",
",",
"opts",
"...",
"ServerOption",
")",
"(",
"*",
"ExtensionManagerServer",
",",
"error",
")",
"{",
"// Initialize nested registry maps",
"registry",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"(",
"map",
"[",
"string",
"]",
"OsqueryPlugin",
")",
")",
"\n",
"for",
"reg",
",",
"_",
":=",
"range",
"validRegistryNames",
"{",
"registry",
"[",
"reg",
"]",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"OsqueryPlugin",
")",
"\n",
"}",
"\n\n",
"manager",
":=",
"&",
"ExtensionManagerServer",
"{",
"name",
":",
"name",
",",
"sockPath",
":",
"sockPath",
",",
"registry",
":",
"registry",
",",
"timeout",
":",
"defaultTimeout",
",",
"pingInterval",
":",
"defaultPingInterval",
",",
"}",
"\n\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"manager",
")",
"\n",
"}",
"\n\n",
"serverClient",
",",
"err",
":=",
"NewClient",
"(",
"sockPath",
",",
"manager",
".",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"manager",
".",
"serverClient",
"=",
"serverClient",
"\n\n",
"return",
"manager",
",",
"nil",
"\n",
"}"
] |
// NewExtensionManagerServer creates a new extension management server
// communicating with osquery over the socket at the provided path. If
// resolving the address or connecting to the socket fails, this function will
// error.
|
[
"NewExtensionManagerServer",
"creates",
"a",
"new",
"extension",
"management",
"server",
"communicating",
"with",
"osquery",
"over",
"the",
"socket",
"at",
"the",
"provided",
"path",
".",
"If",
"resolving",
"the",
"address",
"or",
"connecting",
"to",
"the",
"socket",
"fails",
"this",
"function",
"will",
"error",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L82-L108
|
14,689 |
kolide/osquery-go
|
server.go
|
RegisterPlugin
|
func (s *ExtensionManagerServer) RegisterPlugin(plugins ...OsqueryPlugin) {
s.mutex.Lock()
defer s.mutex.Unlock()
for _, plugin := range plugins {
if !validRegistryNames[plugin.RegistryName()] {
panic("invalid registry name: " + plugin.RegistryName())
}
s.registry[plugin.RegistryName()][plugin.Name()] = plugin
}
}
|
go
|
func (s *ExtensionManagerServer) RegisterPlugin(plugins ...OsqueryPlugin) {
s.mutex.Lock()
defer s.mutex.Unlock()
for _, plugin := range plugins {
if !validRegistryNames[plugin.RegistryName()] {
panic("invalid registry name: " + plugin.RegistryName())
}
s.registry[plugin.RegistryName()][plugin.Name()] = plugin
}
}
|
[
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"RegisterPlugin",
"(",
"plugins",
"...",
"OsqueryPlugin",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"plugin",
":=",
"range",
"plugins",
"{",
"if",
"!",
"validRegistryNames",
"[",
"plugin",
".",
"RegistryName",
"(",
")",
"]",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"plugin",
".",
"RegistryName",
"(",
")",
")",
"\n",
"}",
"\n",
"s",
".",
"registry",
"[",
"plugin",
".",
"RegistryName",
"(",
")",
"]",
"[",
"plugin",
".",
"Name",
"(",
")",
"]",
"=",
"plugin",
"\n",
"}",
"\n",
"}"
] |
// RegisterPlugin adds one or more OsqueryPlugins to this extension manager.
|
[
"RegisterPlugin",
"adds",
"one",
"or",
"more",
"OsqueryPlugins",
"to",
"this",
"extension",
"manager",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L111-L120
|
14,690 |
kolide/osquery-go
|
server.go
|
Run
|
func (s *ExtensionManagerServer) Run() error {
errc := make(chan error)
go func() {
errc <- s.Start()
}()
// Watch for the osquery process going away. If so, initiate shutdown.
go func() {
for {
time.Sleep(s.pingInterval)
status, err := s.serverClient.Ping()
if err != nil {
errc <- errors.Wrap(err, "extension ping failed")
break
}
if status.Code != 0 {
errc <- errors.Errorf("ping returned status %d", status.Code)
break
}
}
}()
err := <-errc
if err := s.Shutdown(context.Background()); err != nil {
return err
}
return err
}
|
go
|
func (s *ExtensionManagerServer) Run() error {
errc := make(chan error)
go func() {
errc <- s.Start()
}()
// Watch for the osquery process going away. If so, initiate shutdown.
go func() {
for {
time.Sleep(s.pingInterval)
status, err := s.serverClient.Ping()
if err != nil {
errc <- errors.Wrap(err, "extension ping failed")
break
}
if status.Code != 0 {
errc <- errors.Errorf("ping returned status %d", status.Code)
break
}
}
}()
err := <-errc
if err := s.Shutdown(context.Background()); err != nil {
return err
}
return err
}
|
[
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Run",
"(",
")",
"error",
"{",
"errc",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"errc",
"<-",
"s",
".",
"Start",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// Watch for the osquery process going away. If so, initiate shutdown.",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"time",
".",
"Sleep",
"(",
"s",
".",
"pingInterval",
")",
"\n\n",
"status",
",",
"err",
":=",
"s",
".",
"serverClient",
".",
"Ping",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errc",
"<-",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"break",
"\n",
"}",
"\n",
"if",
"status",
".",
"Code",
"!=",
"0",
"{",
"errc",
"<-",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"status",
".",
"Code",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"err",
":=",
"<-",
"errc",
"\n",
"if",
"err",
":=",
"s",
".",
"Shutdown",
"(",
"context",
".",
"Background",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Run starts the extension manager and runs until osquery calls for a shutdown
// or the osquery instance goes away.
|
[
"Run",
"starts",
"the",
"extension",
"manager",
"and",
"runs",
"until",
"osquery",
"calls",
"for",
"a",
"shutdown",
"or",
"the",
"osquery",
"instance",
"goes",
"away",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L183-L211
|
14,691 |
kolide/osquery-go
|
server.go
|
Ping
|
func (s *ExtensionManagerServer) Ping(ctx context.Context) (*osquery.ExtensionStatus, error) {
return &osquery.ExtensionStatus{Code: 0, Message: "OK"}, nil
}
|
go
|
func (s *ExtensionManagerServer) Ping(ctx context.Context) (*osquery.ExtensionStatus, error) {
return &osquery.ExtensionStatus{Code: 0, Message: "OK"}, nil
}
|
[
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Ping",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"osquery",
".",
"ExtensionStatus",
",",
"error",
")",
"{",
"return",
"&",
"osquery",
".",
"ExtensionStatus",
"{",
"Code",
":",
"0",
",",
"Message",
":",
"\"",
"\"",
"}",
",",
"nil",
"\n",
"}"
] |
// Ping implements the basic health check.
|
[
"Ping",
"implements",
"the",
"basic",
"health",
"check",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L214-L216
|
14,692 |
kolide/osquery-go
|
server.go
|
Call
|
func (s *ExtensionManagerServer) Call(ctx context.Context, registry string, item string, request osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
subreg, ok := s.registry[registry]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry: " + registry,
},
}, nil
}
plugin, ok := subreg[item]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry item: " + item,
},
}, nil
}
response := plugin.Call(context.Background(), request)
return &response, nil
}
|
go
|
func (s *ExtensionManagerServer) Call(ctx context.Context, registry string, item string, request osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
subreg, ok := s.registry[registry]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry: " + registry,
},
}, nil
}
plugin, ok := subreg[item]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unknown registry item: " + item,
},
}, nil
}
response := plugin.Call(context.Background(), request)
return &response, nil
}
|
[
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Call",
"(",
"ctx",
"context",
".",
"Context",
",",
"registry",
"string",
",",
"item",
"string",
",",
"request",
"osquery",
".",
"ExtensionPluginRequest",
")",
"(",
"*",
"osquery",
".",
"ExtensionResponse",
",",
"error",
")",
"{",
"subreg",
",",
"ok",
":=",
"s",
".",
"registry",
"[",
"registry",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"&",
"osquery",
".",
"ExtensionResponse",
"{",
"Status",
":",
"&",
"osquery",
".",
"ExtensionStatus",
"{",
"Code",
":",
"1",
",",
"Message",
":",
"\"",
"\"",
"+",
"registry",
",",
"}",
",",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"plugin",
",",
"ok",
":=",
"subreg",
"[",
"item",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"&",
"osquery",
".",
"ExtensionResponse",
"{",
"Status",
":",
"&",
"osquery",
".",
"ExtensionStatus",
"{",
"Code",
":",
"1",
",",
"Message",
":",
"\"",
"\"",
"+",
"item",
",",
"}",
",",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"response",
":=",
"plugin",
".",
"Call",
"(",
"context",
".",
"Background",
"(",
")",
",",
"request",
")",
"\n",
"return",
"&",
"response",
",",
"nil",
"\n",
"}"
] |
// Call routes a call from the osquery process to the appropriate registered
// plugin.
|
[
"Call",
"routes",
"a",
"call",
"from",
"the",
"osquery",
"process",
"to",
"the",
"appropriate",
"registered",
"plugin",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L220-L243
|
14,693 |
kolide/osquery-go
|
server.go
|
Shutdown
|
func (s *ExtensionManagerServer) Shutdown(ctx context.Context) error {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.server != nil {
server := s.server
s.server = nil
// Stop the server asynchronously so that the current request
// can complete. Otherwise, this is vulnerable to deadlock if a
// shutdown request is being processed when shutdown is
// explicitly called.
go func() {
server.Stop()
}()
}
return nil
}
|
go
|
func (s *ExtensionManagerServer) Shutdown(ctx context.Context) error {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.server != nil {
server := s.server
s.server = nil
// Stop the server asynchronously so that the current request
// can complete. Otherwise, this is vulnerable to deadlock if a
// shutdown request is being processed when shutdown is
// explicitly called.
go func() {
server.Stop()
}()
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"server",
"!=",
"nil",
"{",
"server",
":=",
"s",
".",
"server",
"\n",
"s",
".",
"server",
"=",
"nil",
"\n",
"// Stop the server asynchronously so that the current request",
"// can complete. Otherwise, this is vulnerable to deadlock if a",
"// shutdown request is being processed when shutdown is",
"// explicitly called.",
"go",
"func",
"(",
")",
"{",
"server",
".",
"Stop",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Shutdown stops the server and closes the listening socket.
|
[
"Shutdown",
"stops",
"the",
"server",
"and",
"closes",
"the",
"listening",
"socket",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L246-L262
|
14,694 |
kolide/osquery-go
|
server.go
|
waitStarted
|
func (s *ExtensionManagerServer) waitStarted() {
for {
s.mutex.Lock()
started := s.started
s.mutex.Unlock()
if started {
time.Sleep(10 * time.Millisecond)
break
}
}
}
|
go
|
func (s *ExtensionManagerServer) waitStarted() {
for {
s.mutex.Lock()
started := s.started
s.mutex.Unlock()
if started {
time.Sleep(10 * time.Millisecond)
break
}
}
}
|
[
"func",
"(",
"s",
"*",
"ExtensionManagerServer",
")",
"waitStarted",
"(",
")",
"{",
"for",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"started",
":=",
"s",
".",
"started",
"\n",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"if",
"started",
"{",
"time",
".",
"Sleep",
"(",
"10",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Useful for testing
|
[
"Useful",
"for",
"testing"
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/server.go#L265-L275
|
14,695 |
kolide/osquery-go
|
plugin/config/config.go
|
NewPlugin
|
func NewPlugin(name string, fn GenerateConfigsFunc) *Plugin {
return &Plugin{name: name, generate: fn}
}
|
go
|
func NewPlugin(name string, fn GenerateConfigsFunc) *Plugin {
return &Plugin{name: name, generate: fn}
}
|
[
"func",
"NewPlugin",
"(",
"name",
"string",
",",
"fn",
"GenerateConfigsFunc",
")",
"*",
"Plugin",
"{",
"return",
"&",
"Plugin",
"{",
"name",
":",
"name",
",",
"generate",
":",
"fn",
"}",
"\n",
"}"
] |
// NewConfigPlugin takes a value that implements ConfigPlugin and wraps it with
// the appropriate methods to satisfy the OsqueryPlugin interface. Use this to
// easily create configuration plugins.
|
[
"NewConfigPlugin",
"takes",
"a",
"value",
"that",
"implements",
"ConfigPlugin",
"and",
"wraps",
"it",
"with",
"the",
"appropriate",
"methods",
"to",
"satisfy",
"the",
"OsqueryPlugin",
"interface",
".",
"Use",
"this",
"to",
"easily",
"create",
"configuration",
"plugins",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/plugin/config/config.go#L28-L30
|
14,696 |
kolide/osquery-go
|
transport/transport.go
|
Open
|
func Open(sockPath string, timeout time.Duration) (*thrift.TSocket, error) {
addr, err := net.ResolveUnixAddr("unix", sockPath)
if err != nil {
return nil, errors.Wrapf(err, "resolving socket path '%s'", sockPath)
}
// the timeout parameter is passed to thrift, which passes it to net.DialTimeout
// but it looks like net.DialTimeout ignores timeouts for unix socket and immediately returns an error
// waitForSocket will loop every 200ms to stat the socket path,
// or until the timeout value passes, similar to the C++ and python implementations.
if err := waitForSocket(sockPath, timeout); err != nil {
return nil, errors.Wrapf(err, "waiting for unix socket to be available: %s", sockPath)
}
trans := thrift.NewTSocketFromAddrTimeout(addr, timeout)
if err := trans.Open(); err != nil {
return nil, errors.Wrap(err, "opening socket transport")
}
return trans, nil
}
|
go
|
func Open(sockPath string, timeout time.Duration) (*thrift.TSocket, error) {
addr, err := net.ResolveUnixAddr("unix", sockPath)
if err != nil {
return nil, errors.Wrapf(err, "resolving socket path '%s'", sockPath)
}
// the timeout parameter is passed to thrift, which passes it to net.DialTimeout
// but it looks like net.DialTimeout ignores timeouts for unix socket and immediately returns an error
// waitForSocket will loop every 200ms to stat the socket path,
// or until the timeout value passes, similar to the C++ and python implementations.
if err := waitForSocket(sockPath, timeout); err != nil {
return nil, errors.Wrapf(err, "waiting for unix socket to be available: %s", sockPath)
}
trans := thrift.NewTSocketFromAddrTimeout(addr, timeout)
if err := trans.Open(); err != nil {
return nil, errors.Wrap(err, "opening socket transport")
}
return trans, nil
}
|
[
"func",
"Open",
"(",
"sockPath",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"thrift",
".",
"TSocket",
",",
"error",
")",
"{",
"addr",
",",
"err",
":=",
"net",
".",
"ResolveUnixAddr",
"(",
"\"",
"\"",
",",
"sockPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"sockPath",
")",
"\n",
"}",
"\n\n",
"// the timeout parameter is passed to thrift, which passes it to net.DialTimeout",
"// but it looks like net.DialTimeout ignores timeouts for unix socket and immediately returns an error",
"// waitForSocket will loop every 200ms to stat the socket path,",
"// or until the timeout value passes, similar to the C++ and python implementations.",
"if",
"err",
":=",
"waitForSocket",
"(",
"sockPath",
",",
"timeout",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"sockPath",
")",
"\n",
"}",
"\n\n",
"trans",
":=",
"thrift",
".",
"NewTSocketFromAddrTimeout",
"(",
"addr",
",",
"timeout",
")",
"\n",
"if",
"err",
":=",
"trans",
".",
"Open",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"trans",
",",
"nil",
"\n",
"}"
] |
// Open opens the unix domain socket with the provided path and timeout,
// returning a TTransport.
|
[
"Open",
"opens",
"the",
"unix",
"domain",
"socket",
"with",
"the",
"provided",
"path",
"and",
"timeout",
"returning",
"a",
"TTransport",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/transport/transport.go#L17-L37
|
14,697 |
kolide/osquery-go
|
client.go
|
NewClient
|
func NewClient(path string, timeout time.Duration) (*ExtensionManagerClient, error) {
trans, err := transport.Open(path, timeout)
if err != nil {
return nil, err
}
client := osquery.NewExtensionManagerClientFactory(
trans,
thrift.NewTBinaryProtocolFactoryDefault(),
)
return &ExtensionManagerClient{client, trans}, nil
}
|
go
|
func NewClient(path string, timeout time.Duration) (*ExtensionManagerClient, error) {
trans, err := transport.Open(path, timeout)
if err != nil {
return nil, err
}
client := osquery.NewExtensionManagerClientFactory(
trans,
thrift.NewTBinaryProtocolFactoryDefault(),
)
return &ExtensionManagerClient{client, trans}, nil
}
|
[
"func",
"NewClient",
"(",
"path",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"ExtensionManagerClient",
",",
"error",
")",
"{",
"trans",
",",
"err",
":=",
"transport",
".",
"Open",
"(",
"path",
",",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"client",
":=",
"osquery",
".",
"NewExtensionManagerClientFactory",
"(",
"trans",
",",
"thrift",
".",
"NewTBinaryProtocolFactoryDefault",
"(",
")",
",",
")",
"\n\n",
"return",
"&",
"ExtensionManagerClient",
"{",
"client",
",",
"trans",
"}",
",",
"nil",
"\n",
"}"
] |
// NewClient creates a new client communicating to osquery over the socket at
// the provided path. If resolving the address or connecting to the socket
// fails, this function will error.
|
[
"NewClient",
"creates",
"a",
"new",
"client",
"communicating",
"to",
"osquery",
"over",
"the",
"socket",
"at",
"the",
"provided",
"path",
".",
"If",
"resolving",
"the",
"address",
"or",
"connecting",
"to",
"the",
"socket",
"fails",
"this",
"function",
"will",
"error",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L34-L46
|
14,698 |
kolide/osquery-go
|
client.go
|
Close
|
func (c *ExtensionManagerClient) Close() {
if c.transport != nil && c.transport.IsOpen() {
c.transport.Close()
}
}
|
go
|
func (c *ExtensionManagerClient) Close() {
if c.transport != nil && c.transport.IsOpen() {
c.transport.Close()
}
}
|
[
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"Close",
"(",
")",
"{",
"if",
"c",
".",
"transport",
"!=",
"nil",
"&&",
"c",
".",
"transport",
".",
"IsOpen",
"(",
")",
"{",
"c",
".",
"transport",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// Close should be called to close the transport when use of the client is
// completed.
|
[
"Close",
"should",
"be",
"called",
"to",
"close",
"the",
"transport",
"when",
"use",
"of",
"the",
"client",
"is",
"completed",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L50-L54
|
14,699 |
kolide/osquery-go
|
client.go
|
Ping
|
func (c *ExtensionManagerClient) Ping() (*osquery.ExtensionStatus, error) {
return c.Client.Ping(context.Background())
}
|
go
|
func (c *ExtensionManagerClient) Ping() (*osquery.ExtensionStatus, error) {
return c.Client.Ping(context.Background())
}
|
[
"func",
"(",
"c",
"*",
"ExtensionManagerClient",
")",
"Ping",
"(",
")",
"(",
"*",
"osquery",
".",
"ExtensionStatus",
",",
"error",
")",
"{",
"return",
"c",
".",
"Client",
".",
"Ping",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}"
] |
// Ping requests metadata from the extension manager.
|
[
"Ping",
"requests",
"metadata",
"from",
"the",
"extension",
"manager",
"."
] |
be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0
|
https://github.com/kolide/osquery-go/blob/be0a8de4cf1d32b0e06dc867f0af55d00cfdfda0/client.go#L57-L59
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.