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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
16,100 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
GetKeys
|
func (r *FastHttpHeader) GetKeys() (value []string) {
addValue := func(k, v []byte) {
found := false
key := string(k)
for _, r := range value {
if key == r {
found = true
break
}
}
if !found {
value = append(value, key)
}
}
if !r.isResponse {
r.Source.(*FastHttpRequest).Original.Request.Header.VisitAll(addValue)
} else {
r.Source.(*FastHttpResponse).Original.Response.Header.VisitAll(addValue)
}
return
}
|
go
|
func (r *FastHttpHeader) GetKeys() (value []string) {
addValue := func(k, v []byte) {
found := false
key := string(k)
for _, r := range value {
if key == r {
found = true
break
}
}
if !found {
value = append(value, key)
}
}
if !r.isResponse {
r.Source.(*FastHttpRequest).Original.Request.Header.VisitAll(addValue)
} else {
r.Source.(*FastHttpResponse).Original.Response.Header.VisitAll(addValue)
}
return
}
|
[
"func",
"(",
"r",
"*",
"FastHttpHeader",
")",
"GetKeys",
"(",
")",
"(",
"value",
"[",
"]",
"string",
")",
"{",
"addValue",
":=",
"func",
"(",
"k",
",",
"v",
"[",
"]",
"byte",
")",
"{",
"found",
":=",
"false",
"\n",
"key",
":=",
"string",
"(",
"k",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"value",
"{",
"if",
"key",
"==",
"r",
"{",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"value",
"=",
"append",
"(",
"value",
",",
"key",
")",
"\n",
"}",
"\n\n",
"}",
"\n",
"if",
"!",
"r",
".",
"isResponse",
"{",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpRequest",
")",
".",
"Original",
".",
"Request",
".",
"Header",
".",
"VisitAll",
"(",
"addValue",
")",
"\n\n",
"}",
"else",
"{",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpResponse",
")",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"VisitAll",
"(",
"addValue",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Returns the header keys
|
[
"Returns",
"the",
"header",
"keys"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L568-L590
|
16,101 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
Get
|
func (r *FastHttpHeader) Get(key string) (value []string) {
if !r.isResponse {
value = strings.Split(string(r.Source.(*FastHttpRequest).Original.Request.Header.Peek(key)), ",")
} else {
value = strings.Split(string(r.Source.(*FastHttpResponse).Original.Response.Header.Peek(key)), ",")
}
return
}
|
go
|
func (r *FastHttpHeader) Get(key string) (value []string) {
if !r.isResponse {
value = strings.Split(string(r.Source.(*FastHttpRequest).Original.Request.Header.Peek(key)), ",")
} else {
value = strings.Split(string(r.Source.(*FastHttpResponse).Original.Response.Header.Peek(key)), ",")
}
return
}
|
[
"func",
"(",
"r",
"*",
"FastHttpHeader",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"value",
"[",
"]",
"string",
")",
"{",
"if",
"!",
"r",
".",
"isResponse",
"{",
"value",
"=",
"strings",
".",
"Split",
"(",
"string",
"(",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpRequest",
")",
".",
"Original",
".",
"Request",
".",
"Header",
".",
"Peek",
"(",
"key",
")",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"value",
"=",
"strings",
".",
"Split",
"(",
"string",
"(",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpResponse",
")",
".",
"Original",
".",
"Response",
".",
"Header",
".",
"Peek",
"(",
"key",
")",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// returns the header value
|
[
"returns",
"the",
"header",
"value"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L593-L600
|
16,102 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
SetStatus
|
func (r *FastHttpHeader) SetStatus(statusCode int) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.SetStatusCode(statusCode)
}
}
|
go
|
func (r *FastHttpHeader) SetStatus(statusCode int) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.SetStatusCode(statusCode)
}
}
|
[
"func",
"(",
"r",
"*",
"FastHttpHeader",
")",
"SetStatus",
"(",
"statusCode",
"int",
")",
"{",
"if",
"r",
".",
"isResponse",
"{",
"r",
".",
"Source",
".",
"(",
"*",
"FastHttpResponse",
")",
".",
"Original",
".",
"Response",
".",
"SetStatusCode",
"(",
"statusCode",
")",
"\n",
"}",
"\n",
"}"
] |
// Sets the header status
|
[
"Sets",
"the",
"header",
"status"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L603-L607
|
16,103 |
revel/modules
|
server-engine/fasthttp/app/server-fasthttp.go
|
GetValues
|
func (f *FastHttpMultipartForm) GetValues() url.Values {
return url.Values(f.Form.Value)
}
|
go
|
func (f *FastHttpMultipartForm) GetValues() url.Values {
return url.Values(f.Form.Value)
}
|
[
"func",
"(",
"f",
"*",
"FastHttpMultipartForm",
")",
"GetValues",
"(",
")",
"url",
".",
"Values",
"{",
"return",
"url",
".",
"Values",
"(",
"f",
".",
"Form",
".",
"Value",
")",
"\n",
"}"
] |
// Returns the values for a form
|
[
"Returns",
"the",
"values",
"for",
"a",
"form"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/server-fasthttp.go#L620-L622
|
16,104 |
revel/modules
|
template-engine/ace/app/init.go
|
Render
|
func (acetmpl AceTemplate) Render(wr io.Writer, arg interface{}) error {
// We can redirect this render to another template if the arguments contain ace_content in them
if argmap, ok := arg.(map[string]interface{}); ok {
if acecontentraw, ok := argmap["ace-inner"]; ok {
acecontent := acecontentraw.(string)
newtemplatename := acetmpl.TemplateName + "-" + acecontent
// Now lookup the template again
if _, ok := acetmpl.engine.templatesByName[newtemplatename]; !ok {
if inner, ok := acetmpl.engine.templatesByName[acecontent]; !ok {
return fmt.Errorf("Inner content %s not found in ace templates", acecontent)
} else {
acetmpl.engine.templatesByName[newtemplatename] = &AceTemplate{
File: acetmpl.File,
Inner: inner.File,
engine: acetmpl.engine,
TemplateView: acetmpl.TemplateView}
}
}
return acetmpl.engine.templatesByName[newtemplatename].renderInternal(wr, arg)
}
}
return acetmpl.renderInternal(wr, arg)
}
|
go
|
func (acetmpl AceTemplate) Render(wr io.Writer, arg interface{}) error {
// We can redirect this render to another template if the arguments contain ace_content in them
if argmap, ok := arg.(map[string]interface{}); ok {
if acecontentraw, ok := argmap["ace-inner"]; ok {
acecontent := acecontentraw.(string)
newtemplatename := acetmpl.TemplateName + "-" + acecontent
// Now lookup the template again
if _, ok := acetmpl.engine.templatesByName[newtemplatename]; !ok {
if inner, ok := acetmpl.engine.templatesByName[acecontent]; !ok {
return fmt.Errorf("Inner content %s not found in ace templates", acecontent)
} else {
acetmpl.engine.templatesByName[newtemplatename] = &AceTemplate{
File: acetmpl.File,
Inner: inner.File,
engine: acetmpl.engine,
TemplateView: acetmpl.TemplateView}
}
}
return acetmpl.engine.templatesByName[newtemplatename].renderInternal(wr, arg)
}
}
return acetmpl.renderInternal(wr, arg)
}
|
[
"func",
"(",
"acetmpl",
"AceTemplate",
")",
"Render",
"(",
"wr",
"io",
".",
"Writer",
",",
"arg",
"interface",
"{",
"}",
")",
"error",
"{",
"// We can redirect this render to another template if the arguments contain ace_content in them",
"if",
"argmap",
",",
"ok",
":=",
"arg",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"if",
"acecontentraw",
",",
"ok",
":=",
"argmap",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"acecontent",
":=",
"acecontentraw",
".",
"(",
"string",
")",
"\n",
"newtemplatename",
":=",
"acetmpl",
".",
"TemplateName",
"+",
"\"",
"\"",
"+",
"acecontent",
"\n",
"// Now lookup the template again",
"if",
"_",
",",
"ok",
":=",
"acetmpl",
".",
"engine",
".",
"templatesByName",
"[",
"newtemplatename",
"]",
";",
"!",
"ok",
"{",
"if",
"inner",
",",
"ok",
":=",
"acetmpl",
".",
"engine",
".",
"templatesByName",
"[",
"acecontent",
"]",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"acecontent",
")",
"\n",
"}",
"else",
"{",
"acetmpl",
".",
"engine",
".",
"templatesByName",
"[",
"newtemplatename",
"]",
"=",
"&",
"AceTemplate",
"{",
"File",
":",
"acetmpl",
".",
"File",
",",
"Inner",
":",
"inner",
".",
"File",
",",
"engine",
":",
"acetmpl",
".",
"engine",
",",
"TemplateView",
":",
"acetmpl",
".",
"TemplateView",
"}",
"\n",
"}",
"\n\n",
"}",
"\n",
"return",
"acetmpl",
".",
"engine",
".",
"templatesByName",
"[",
"newtemplatename",
"]",
".",
"renderInternal",
"(",
"wr",
",",
"arg",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"acetmpl",
".",
"renderInternal",
"(",
"wr",
",",
"arg",
")",
"\n",
"}"
] |
// A bit trick of an implementation
// If the arg contains an ace_inner field then that will be used
// to fetch a new template
|
[
"A",
"bit",
"trick",
"of",
"an",
"implementation",
"If",
"the",
"arg",
"contains",
"an",
"ace_inner",
"field",
"then",
"that",
"will",
"be",
"used",
"to",
"fetch",
"a",
"new",
"template"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/template-engine/ace/app/init.go#L26-L49
|
16,105 |
revel/modules
|
db/app/db.go
|
Init
|
func Init() {
// Read configuration.
var found bool
if Driver, found = revel.Config.String("db.driver"); !found {
revel.RevelLog.Fatal("db.driver not configured")
}
if Spec, found = revel.Config.String("db.spec"); !found {
revel.RevelLog.Fatal("db.spec not configured")
}
// Open a connection.
var err error
Db, err = sql.Open(Driver, Spec)
if err != nil {
revel.RevelLog.Fatal("Open database connection error", "error", err, "driver", Driver, "spec", Spec)
}
revel.OnAppStop(func() {
revel.RevelLog.Info("Closing the database (from module)")
if err := Db.Close(); err != nil {
revel.AppLog.Error("Failed to close the database", "error", err)
}
})
}
|
go
|
func Init() {
// Read configuration.
var found bool
if Driver, found = revel.Config.String("db.driver"); !found {
revel.RevelLog.Fatal("db.driver not configured")
}
if Spec, found = revel.Config.String("db.spec"); !found {
revel.RevelLog.Fatal("db.spec not configured")
}
// Open a connection.
var err error
Db, err = sql.Open(Driver, Spec)
if err != nil {
revel.RevelLog.Fatal("Open database connection error", "error", err, "driver", Driver, "spec", Spec)
}
revel.OnAppStop(func() {
revel.RevelLog.Info("Closing the database (from module)")
if err := Db.Close(); err != nil {
revel.AppLog.Error("Failed to close the database", "error", err)
}
})
}
|
[
"func",
"Init",
"(",
")",
"{",
"// Read configuration.",
"var",
"found",
"bool",
"\n",
"if",
"Driver",
",",
"found",
"=",
"revel",
".",
"Config",
".",
"String",
"(",
"\"",
"\"",
")",
";",
"!",
"found",
"{",
"revel",
".",
"RevelLog",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"Spec",
",",
"found",
"=",
"revel",
".",
"Config",
".",
"String",
"(",
"\"",
"\"",
")",
";",
"!",
"found",
"{",
"revel",
".",
"RevelLog",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Open a connection.",
"var",
"err",
"error",
"\n",
"Db",
",",
"err",
"=",
"sql",
".",
"Open",
"(",
"Driver",
",",
"Spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"revel",
".",
"RevelLog",
".",
"Fatal",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
",",
"\"",
"\"",
",",
"Driver",
",",
"\"",
"\"",
",",
"Spec",
")",
"\n",
"}",
"\n\n",
"revel",
".",
"OnAppStop",
"(",
"func",
"(",
")",
"{",
"revel",
".",
"RevelLog",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"Db",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"revel",
".",
"AppLog",
".",
"Error",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] |
// Init method used to initialize DB module on `OnAppStart`
|
[
"Init",
"method",
"used",
"to",
"initialize",
"DB",
"module",
"on",
"OnAppStart"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/db/app/db.go#L30-L53
|
16,106 |
revel/modules
|
orm/gorp/app/init_db.go
|
InitDb
|
func InitDb(dbResult *DbGorp) error {
params := DbInfo{}
params.DbDriver = revel.Config.StringDefault("db.driver", "sqlite3")
params.DbHost = revel.Config.StringDefault("db.host", "localhost")
if params.DbDriver == "sqlite3" && params.DbHost == "localhost" {
params.DbHost = "/tmp/app.db"
}
params.DbUser = revel.Config.StringDefault("db.user", "default")
params.DbPassword = revel.Config.StringDefault("db.password", "")
params.DbName = revel.Config.StringDefault("db.name", "default")
params.DbConnection = revel.Config.StringDefault("db.connection", "")
params.DbSchema = revel.Config.StringDefault("db.schema", "")
dbResult.Info = ¶ms
return dbResult.InitDb(true)
}
|
go
|
func InitDb(dbResult *DbGorp) error {
params := DbInfo{}
params.DbDriver = revel.Config.StringDefault("db.driver", "sqlite3")
params.DbHost = revel.Config.StringDefault("db.host", "localhost")
if params.DbDriver == "sqlite3" && params.DbHost == "localhost" {
params.DbHost = "/tmp/app.db"
}
params.DbUser = revel.Config.StringDefault("db.user", "default")
params.DbPassword = revel.Config.StringDefault("db.password", "")
params.DbName = revel.Config.StringDefault("db.name", "default")
params.DbConnection = revel.Config.StringDefault("db.connection", "")
params.DbSchema = revel.Config.StringDefault("db.schema", "")
dbResult.Info = ¶ms
return dbResult.InitDb(true)
}
|
[
"func",
"InitDb",
"(",
"dbResult",
"*",
"DbGorp",
")",
"error",
"{",
"params",
":=",
"DbInfo",
"{",
"}",
"\n",
"params",
".",
"DbDriver",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"params",
".",
"DbHost",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"params",
".",
"DbDriver",
"==",
"\"",
"\"",
"&&",
"params",
".",
"DbHost",
"==",
"\"",
"\"",
"{",
"params",
".",
"DbHost",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"params",
".",
"DbUser",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"params",
".",
"DbPassword",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"params",
".",
"DbName",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"params",
".",
"DbConnection",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"params",
".",
"DbSchema",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"dbResult",
".",
"Info",
"=",
"&",
"params",
"\n\n",
"return",
"dbResult",
".",
"InitDb",
"(",
"true",
")",
"\n",
"}"
] |
// Initialize the database from revel.Config
|
[
"Initialize",
"the",
"database",
"from",
"revel",
".",
"Config"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/init_db.go#L61-L76
|
16,107 |
revel/modules
|
csrf/app/csrf.go
|
validToken
|
func validToken(token string, isSameOrigin, foundToken bool, c *revel.Controller) (result bool) {
// Token wasn't present at all
if !foundToken {
c.Result = c.Forbidden("REVEL CSRF: Session token missing.")
return
}
// Same origin
if !isSameOrigin {
c.Result = c.Forbidden("REVEL CSRF: Same origin mismatch.")
return
}
var requestToken string
// First check for token in post data
if c.Request.Method == "POST" {
requestToken = c.Params.Get("csrftoken")
}
// Then check for token in custom headers, as with AJAX
if requestToken == "" {
requestToken = c.Request.GetHttpHeader("X-CSRFToken")
}
if requestToken == "" || !compareToken(requestToken, token) {
c.Result = c.Forbidden("REVEL CSRF: Invalid token.")
return
}
return true
}
|
go
|
func validToken(token string, isSameOrigin, foundToken bool, c *revel.Controller) (result bool) {
// Token wasn't present at all
if !foundToken {
c.Result = c.Forbidden("REVEL CSRF: Session token missing.")
return
}
// Same origin
if !isSameOrigin {
c.Result = c.Forbidden("REVEL CSRF: Same origin mismatch.")
return
}
var requestToken string
// First check for token in post data
if c.Request.Method == "POST" {
requestToken = c.Params.Get("csrftoken")
}
// Then check for token in custom headers, as with AJAX
if requestToken == "" {
requestToken = c.Request.GetHttpHeader("X-CSRFToken")
}
if requestToken == "" || !compareToken(requestToken, token) {
c.Result = c.Forbidden("REVEL CSRF: Invalid token.")
return
}
return true
}
|
[
"func",
"validToken",
"(",
"token",
"string",
",",
"isSameOrigin",
",",
"foundToken",
"bool",
",",
"c",
"*",
"revel",
".",
"Controller",
")",
"(",
"result",
"bool",
")",
"{",
"// Token wasn't present at all",
"if",
"!",
"foundToken",
"{",
"c",
".",
"Result",
"=",
"c",
".",
"Forbidden",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Same origin",
"if",
"!",
"isSameOrigin",
"{",
"c",
".",
"Result",
"=",
"c",
".",
"Forbidden",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"var",
"requestToken",
"string",
"\n",
"// First check for token in post data",
"if",
"c",
".",
"Request",
".",
"Method",
"==",
"\"",
"\"",
"{",
"requestToken",
"=",
"c",
".",
"Params",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Then check for token in custom headers, as with AJAX",
"if",
"requestToken",
"==",
"\"",
"\"",
"{",
"requestToken",
"=",
"c",
".",
"Request",
".",
"GetHttpHeader",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"requestToken",
"==",
"\"",
"\"",
"||",
"!",
"compareToken",
"(",
"requestToken",
",",
"token",
")",
"{",
"c",
".",
"Result",
"=",
"c",
".",
"Forbidden",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// If this call should be checked validate token
|
[
"If",
"this",
"call",
"should",
"be",
"checked",
"validate",
"token"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/csrf/app/csrf.go#L87-L117
|
16,108 |
revel/modules
|
csrf/app/csrf.go
|
getFullRequestURL
|
func getFullRequestURL(c *revel.Controller) (requestUrl *url.URL) {
requestUrl = c.Request.URL
c.Log.Debug("Using ", "request url host", requestUrl.Host, "request host", c.Request.Host, "cookie domain", revel.CookieDomain)
// Update any of the information based on the headers
if host := c.Request.GetHttpHeader("X-Forwarded-Host"); host != "" {
requestUrl.Host = strings.ToLower(host)
}
if scheme := c.Request.GetHttpHeader("X-Forwarded-Proto"); scheme != "" {
requestUrl.Scheme = strings.ToLower(scheme)
}
if scheme := c.Request.GetHttpHeader("X-Forwarded-Scheme"); scheme != "" {
requestUrl.Scheme = strings.ToLower(scheme)
}
// Use the revel.CookieDomain for the hostname, or the c.Request.Host
if requestUrl.Host == "" {
host := revel.CookieDomain
if host == "" && c.Request.Host != "" {
host = c.Request.Host
// Slice off any port information.
if i := strings.Index(host, ":"); i != -1 {
host = host[:i]
}
}
requestUrl.Host = host
}
// If no scheme found in headers use the revel server settings
if requestUrl.Scheme == "" {
// Fix the Request.URL, it is missing information, go http server does this
if revel.HTTPSsl {
requestUrl.Scheme = "https"
} else {
requestUrl.Scheme = "http"
}
fixedUrl := requestUrl.Scheme + "://" + c.Request.Host + c.Request.URL.Path
if purl, err := url.Parse(fixedUrl); err == nil {
requestUrl = purl
}
}
c.Log.Debug("getFullRequestURL ", "requesturl", requestUrl.String())
return
}
|
go
|
func getFullRequestURL(c *revel.Controller) (requestUrl *url.URL) {
requestUrl = c.Request.URL
c.Log.Debug("Using ", "request url host", requestUrl.Host, "request host", c.Request.Host, "cookie domain", revel.CookieDomain)
// Update any of the information based on the headers
if host := c.Request.GetHttpHeader("X-Forwarded-Host"); host != "" {
requestUrl.Host = strings.ToLower(host)
}
if scheme := c.Request.GetHttpHeader("X-Forwarded-Proto"); scheme != "" {
requestUrl.Scheme = strings.ToLower(scheme)
}
if scheme := c.Request.GetHttpHeader("X-Forwarded-Scheme"); scheme != "" {
requestUrl.Scheme = strings.ToLower(scheme)
}
// Use the revel.CookieDomain for the hostname, or the c.Request.Host
if requestUrl.Host == "" {
host := revel.CookieDomain
if host == "" && c.Request.Host != "" {
host = c.Request.Host
// Slice off any port information.
if i := strings.Index(host, ":"); i != -1 {
host = host[:i]
}
}
requestUrl.Host = host
}
// If no scheme found in headers use the revel server settings
if requestUrl.Scheme == "" {
// Fix the Request.URL, it is missing information, go http server does this
if revel.HTTPSsl {
requestUrl.Scheme = "https"
} else {
requestUrl.Scheme = "http"
}
fixedUrl := requestUrl.Scheme + "://" + c.Request.Host + c.Request.URL.Path
if purl, err := url.Parse(fixedUrl); err == nil {
requestUrl = purl
}
}
c.Log.Debug("getFullRequestURL ", "requesturl", requestUrl.String())
return
}
|
[
"func",
"getFullRequestURL",
"(",
"c",
"*",
"revel",
".",
"Controller",
")",
"(",
"requestUrl",
"*",
"url",
".",
"URL",
")",
"{",
"requestUrl",
"=",
"c",
".",
"Request",
".",
"URL",
"\n\n",
"c",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"requestUrl",
".",
"Host",
",",
"\"",
"\"",
",",
"c",
".",
"Request",
".",
"Host",
",",
"\"",
"\"",
",",
"revel",
".",
"CookieDomain",
")",
"\n",
"// Update any of the information based on the headers",
"if",
"host",
":=",
"c",
".",
"Request",
".",
"GetHttpHeader",
"(",
"\"",
"\"",
")",
";",
"host",
"!=",
"\"",
"\"",
"{",
"requestUrl",
".",
"Host",
"=",
"strings",
".",
"ToLower",
"(",
"host",
")",
"\n",
"}",
"\n",
"if",
"scheme",
":=",
"c",
".",
"Request",
".",
"GetHttpHeader",
"(",
"\"",
"\"",
")",
";",
"scheme",
"!=",
"\"",
"\"",
"{",
"requestUrl",
".",
"Scheme",
"=",
"strings",
".",
"ToLower",
"(",
"scheme",
")",
"\n",
"}",
"\n",
"if",
"scheme",
":=",
"c",
".",
"Request",
".",
"GetHttpHeader",
"(",
"\"",
"\"",
")",
";",
"scheme",
"!=",
"\"",
"\"",
"{",
"requestUrl",
".",
"Scheme",
"=",
"strings",
".",
"ToLower",
"(",
"scheme",
")",
"\n",
"}",
"\n\n",
"// Use the revel.CookieDomain for the hostname, or the c.Request.Host",
"if",
"requestUrl",
".",
"Host",
"==",
"\"",
"\"",
"{",
"host",
":=",
"revel",
".",
"CookieDomain",
"\n",
"if",
"host",
"==",
"\"",
"\"",
"&&",
"c",
".",
"Request",
".",
"Host",
"!=",
"\"",
"\"",
"{",
"host",
"=",
"c",
".",
"Request",
".",
"Host",
"\n",
"// Slice off any port information.",
"if",
"i",
":=",
"strings",
".",
"Index",
"(",
"host",
",",
"\"",
"\"",
")",
";",
"i",
"!=",
"-",
"1",
"{",
"host",
"=",
"host",
"[",
":",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"requestUrl",
".",
"Host",
"=",
"host",
"\n",
"}",
"\n\n",
"// If no scheme found in headers use the revel server settings",
"if",
"requestUrl",
".",
"Scheme",
"==",
"\"",
"\"",
"{",
"// Fix the Request.URL, it is missing information, go http server does this",
"if",
"revel",
".",
"HTTPSsl",
"{",
"requestUrl",
".",
"Scheme",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"requestUrl",
".",
"Scheme",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"fixedUrl",
":=",
"requestUrl",
".",
"Scheme",
"+",
"\"",
"\"",
"+",
"c",
".",
"Request",
".",
"Host",
"+",
"c",
".",
"Request",
".",
"URL",
".",
"Path",
"\n",
"if",
"purl",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"fixedUrl",
")",
";",
"err",
"==",
"nil",
"{",
"requestUrl",
"=",
"purl",
"\n",
"}",
"\n",
"}",
"\n\n",
"c",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"requestUrl",
".",
"String",
"(",
")",
")",
"\n",
"return",
"\n",
"}"
] |
// Helper function to fix the full URL in the request
|
[
"Helper",
"function",
"to",
"fix",
"the",
"full",
"URL",
"in",
"the",
"request"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/csrf/app/csrf.go#L120-L164
|
16,109 |
revel/modules
|
csrf/app/csrf.go
|
compareToken
|
func compareToken(requestToken, token string) bool {
// ConstantTimeCompare will panic if the []byte aren't the same length
if len(requestToken) != len(token) {
return false
}
return subtle.ConstantTimeCompare([]byte(requestToken), []byte(token)) == 1
}
|
go
|
func compareToken(requestToken, token string) bool {
// ConstantTimeCompare will panic if the []byte aren't the same length
if len(requestToken) != len(token) {
return false
}
return subtle.ConstantTimeCompare([]byte(requestToken), []byte(token)) == 1
}
|
[
"func",
"compareToken",
"(",
"requestToken",
",",
"token",
"string",
")",
"bool",
"{",
"// ConstantTimeCompare will panic if the []byte aren't the same length",
"if",
"len",
"(",
"requestToken",
")",
"!=",
"len",
"(",
"token",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"subtle",
".",
"ConstantTimeCompare",
"(",
"[",
"]",
"byte",
"(",
"requestToken",
")",
",",
"[",
"]",
"byte",
"(",
"token",
")",
")",
"==",
"1",
"\n",
"}"
] |
// Compare the two tokens
|
[
"Compare",
"the",
"two",
"tokens"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/csrf/app/csrf.go#L167-L173
|
16,110 |
revel/modules
|
csrf/app/csrf.go
|
sameOrigin
|
func sameOrigin(u1, u2 *url.URL) bool {
return u1.Scheme == u2.Scheme && u1.Hostname() == u2.Hostname()
}
|
go
|
func sameOrigin(u1, u2 *url.URL) bool {
return u1.Scheme == u2.Scheme && u1.Hostname() == u2.Hostname()
}
|
[
"func",
"sameOrigin",
"(",
"u1",
",",
"u2",
"*",
"url",
".",
"URL",
")",
"bool",
"{",
"return",
"u1",
".",
"Scheme",
"==",
"u2",
".",
"Scheme",
"&&",
"u1",
".",
"Hostname",
"(",
")",
"==",
"u2",
".",
"Hostname",
"(",
")",
"\n",
"}"
] |
// Validates same origin policy
|
[
"Validates",
"same",
"origin",
"policy"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/csrf/app/csrf.go#L176-L178
|
16,111 |
revel/modules
|
csrf/app/csrf.go
|
init
|
func init() {
revel.TemplateFuncs["csrftoken"] = func(viewArgs map[string]interface{}) template.HTML {
if tokenFunc, ok := viewArgs["_csrftoken"]; !ok {
panic("REVEL CSRF: _csrftoken missing from ViewArgs.")
} else {
return template.HTML(tokenFunc.(string))
}
}
}
|
go
|
func init() {
revel.TemplateFuncs["csrftoken"] = func(viewArgs map[string]interface{}) template.HTML {
if tokenFunc, ok := viewArgs["_csrftoken"]; !ok {
panic("REVEL CSRF: _csrftoken missing from ViewArgs.")
} else {
return template.HTML(tokenFunc.(string))
}
}
}
|
[
"func",
"init",
"(",
")",
"{",
"revel",
".",
"TemplateFuncs",
"[",
"\"",
"\"",
"]",
"=",
"func",
"(",
"viewArgs",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"template",
".",
"HTML",
"{",
"if",
"tokenFunc",
",",
"ok",
":=",
"viewArgs",
"[",
"\"",
"\"",
"]",
";",
"!",
"ok",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"return",
"template",
".",
"HTML",
"(",
"tokenFunc",
".",
"(",
"string",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Add a function to the template functions map
|
[
"Add",
"a",
"function",
"to",
"the",
"template",
"functions",
"map"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/csrf/app/csrf.go#L181-L189
|
16,112 |
revel/modules
|
auth/casbin/adapter.go
|
NewAdapter
|
func NewAdapter(params gormdb.DbInfo) *Adapter {
a := &Adapter{}
gormdb.InitDBWithParameters(params)
a.db = gormdb.DB
return a
}
|
go
|
func NewAdapter(params gormdb.DbInfo) *Adapter {
a := &Adapter{}
gormdb.InitDBWithParameters(params)
a.db = gormdb.DB
return a
}
|
[
"func",
"NewAdapter",
"(",
"params",
"gormdb",
".",
"DbInfo",
")",
"*",
"Adapter",
"{",
"a",
":=",
"&",
"Adapter",
"{",
"}",
"\n",
"gormdb",
".",
"InitDBWithParameters",
"(",
"params",
")",
"\n",
"a",
".",
"db",
"=",
"gormdb",
".",
"DB",
"\n\n",
"return",
"a",
"\n",
"}"
] |
// NewAdapter is the constructor for Adapter.
|
[
"NewAdapter",
"is",
"the",
"constructor",
"for",
"Adapter",
"."
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/auth/casbin/adapter.go#L30-L36
|
16,113 |
revel/modules
|
auth/casbin/adapter.go
|
LoadPolicy
|
func (a *Adapter) LoadPolicy(model model.Model) error {
var lines []Line
err := a.db.Find(&lines).Error
if err != nil {
return err
}
for _, line := range lines {
loadPolicyLine(line, model)
}
return nil
}
|
go
|
func (a *Adapter) LoadPolicy(model model.Model) error {
var lines []Line
err := a.db.Find(&lines).Error
if err != nil {
return err
}
for _, line := range lines {
loadPolicyLine(line, model)
}
return nil
}
|
[
"func",
"(",
"a",
"*",
"Adapter",
")",
"LoadPolicy",
"(",
"model",
"model",
".",
"Model",
")",
"error",
"{",
"var",
"lines",
"[",
"]",
"Line",
"\n",
"err",
":=",
"a",
".",
"db",
".",
"Find",
"(",
"&",
"lines",
")",
".",
"Error",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"line",
":=",
"range",
"lines",
"{",
"loadPolicyLine",
"(",
"line",
",",
"model",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// LoadPolicy loads policy from database.
|
[
"LoadPolicy",
"loads",
"policy",
"from",
"database",
"."
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/auth/casbin/adapter.go#L81-L93
|
16,114 |
revel/modules
|
auth/casbin/adapter.go
|
SavePolicy
|
func (a *Adapter) SavePolicy(model model.Model) error {
a.dropTable()
a.createTable()
for ptype, ast := range model["p"] {
for _, rule := range ast.Policy {
line := savePolicyLine(ptype, rule)
err := a.db.Create(&line).Error
if err != nil {
return err
}
}
}
for ptype, ast := range model["g"] {
for _, rule := range ast.Policy {
line := savePolicyLine(ptype, rule)
err := a.db.Create(&line).Error
if err != nil {
return err
}
}
}
return nil
}
|
go
|
func (a *Adapter) SavePolicy(model model.Model) error {
a.dropTable()
a.createTable()
for ptype, ast := range model["p"] {
for _, rule := range ast.Policy {
line := savePolicyLine(ptype, rule)
err := a.db.Create(&line).Error
if err != nil {
return err
}
}
}
for ptype, ast := range model["g"] {
for _, rule := range ast.Policy {
line := savePolicyLine(ptype, rule)
err := a.db.Create(&line).Error
if err != nil {
return err
}
}
}
return nil
}
|
[
"func",
"(",
"a",
"*",
"Adapter",
")",
"SavePolicy",
"(",
"model",
"model",
".",
"Model",
")",
"error",
"{",
"a",
".",
"dropTable",
"(",
")",
"\n",
"a",
".",
"createTable",
"(",
")",
"\n\n",
"for",
"ptype",
",",
"ast",
":=",
"range",
"model",
"[",
"\"",
"\"",
"]",
"{",
"for",
"_",
",",
"rule",
":=",
"range",
"ast",
".",
"Policy",
"{",
"line",
":=",
"savePolicyLine",
"(",
"ptype",
",",
"rule",
")",
"\n",
"err",
":=",
"a",
".",
"db",
".",
"Create",
"(",
"&",
"line",
")",
".",
"Error",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"ptype",
",",
"ast",
":=",
"range",
"model",
"[",
"\"",
"\"",
"]",
"{",
"for",
"_",
",",
"rule",
":=",
"range",
"ast",
".",
"Policy",
"{",
"line",
":=",
"savePolicyLine",
"(",
"ptype",
",",
"rule",
")",
"\n",
"err",
":=",
"a",
".",
"db",
".",
"Create",
"(",
"&",
"line",
")",
".",
"Error",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// SavePolicy saves policy to database.
|
[
"SavePolicy",
"saves",
"policy",
"to",
"database",
"."
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/auth/casbin/adapter.go#L122-L147
|
16,115 |
revel/modules
|
server-engine/fasthttp/app/graceful_listener.go
|
NewGracefulListener
|
func NewGracefulListener(ln net.Listener, maxWaitTime time.Duration) net.Listener {
return &GracefulListener{
ln: ln,
maxWaitTime: maxWaitTime,
done: make(chan struct{}),
}
}
|
go
|
func NewGracefulListener(ln net.Listener, maxWaitTime time.Duration) net.Listener {
return &GracefulListener{
ln: ln,
maxWaitTime: maxWaitTime,
done: make(chan struct{}),
}
}
|
[
"func",
"NewGracefulListener",
"(",
"ln",
"net",
".",
"Listener",
",",
"maxWaitTime",
"time",
".",
"Duration",
")",
"net",
".",
"Listener",
"{",
"return",
"&",
"GracefulListener",
"{",
"ln",
":",
"ln",
",",
"maxWaitTime",
":",
"maxWaitTime",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] |
// NewGracefulListener wraps the given listener into 'graceful shutdown' listener.
|
[
"NewGracefulListener",
"wraps",
"the",
"given",
"listener",
"into",
"graceful",
"shutdown",
"listener",
"."
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/graceful_listener.go#L28-L34
|
16,116 |
revel/modules
|
server-engine/fasthttp/app/graceful_listener.go
|
Close
|
func (ln *GracefulListener) Close() error {
err := ln.ln.Close()
if err != nil {
return nil
}
return ln.waitForZeroConns()
}
|
go
|
func (ln *GracefulListener) Close() error {
err := ln.ln.Close()
if err != nil {
return nil
}
return ln.waitForZeroConns()
}
|
[
"func",
"(",
"ln",
"*",
"GracefulListener",
")",
"Close",
"(",
")",
"error",
"{",
"err",
":=",
"ln",
".",
"ln",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"ln",
".",
"waitForZeroConns",
"(",
")",
"\n",
"}"
] |
// Close closes the inner listener and waits until all the pending open connections
// are closed before returning.
|
[
"Close",
"closes",
"the",
"inner",
"listener",
"and",
"waits",
"until",
"all",
"the",
"pending",
"open",
"connections",
"are",
"closed",
"before",
"returning",
"."
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/fasthttp/app/graceful_listener.go#L57-L65
|
16,117 |
revel/modules
|
template-engine/pongo2/app/init.go
|
Render
|
func (tmpl PongoTemplate) Render(wr io.Writer, arg interface{}) (err error) {
gls.With(gls.Values(map[interface{}]interface{}{"data": arg}), func() {
err = tmpl.template.ExecuteWriter(p2.Context(arg.(map[string]interface{})), wr)
if nil != err {
if e, ok := err.(*p2.Error); ok {
rerr := &revel.Error{
Title: "Template Execution Error",
Path: tmpl.TemplateName,
Description: e.Error(),
Line: e.Line,
}
if revel.DevMode {
rerr.SourceLines = tmpl.Content()
}
err = rerr
}
}
})
return err
}
|
go
|
func (tmpl PongoTemplate) Render(wr io.Writer, arg interface{}) (err error) {
gls.With(gls.Values(map[interface{}]interface{}{"data": arg}), func() {
err = tmpl.template.ExecuteWriter(p2.Context(arg.(map[string]interface{})), wr)
if nil != err {
if e, ok := err.(*p2.Error); ok {
rerr := &revel.Error{
Title: "Template Execution Error",
Path: tmpl.TemplateName,
Description: e.Error(),
Line: e.Line,
}
if revel.DevMode {
rerr.SourceLines = tmpl.Content()
}
err = rerr
}
}
})
return err
}
|
[
"func",
"(",
"tmpl",
"PongoTemplate",
")",
"Render",
"(",
"wr",
"io",
".",
"Writer",
",",
"arg",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"gls",
".",
"With",
"(",
"gls",
".",
"Values",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"arg",
"}",
")",
",",
"func",
"(",
")",
"{",
"err",
"=",
"tmpl",
".",
"template",
".",
"ExecuteWriter",
"(",
"p2",
".",
"Context",
"(",
"arg",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
")",
",",
"wr",
")",
"\n",
"if",
"nil",
"!=",
"err",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"p2",
".",
"Error",
")",
";",
"ok",
"{",
"rerr",
":=",
"&",
"revel",
".",
"Error",
"{",
"Title",
":",
"\"",
"\"",
",",
"Path",
":",
"tmpl",
".",
"TemplateName",
",",
"Description",
":",
"e",
".",
"Error",
"(",
")",
",",
"Line",
":",
"e",
".",
"Line",
",",
"}",
"\n",
"if",
"revel",
".",
"DevMode",
"{",
"rerr",
".",
"SourceLines",
"=",
"tmpl",
".",
"Content",
"(",
")",
"\n",
"}",
"\n",
"err",
"=",
"rerr",
"\n",
"}",
"\n",
"}",
"\n",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// return a 'revel.Template' from HAML's template.
|
[
"return",
"a",
"revel",
".",
"Template",
"from",
"HAML",
"s",
"template",
"."
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/template-engine/pongo2/app/init.go#L51-L70
|
16,118 |
revel/modules
|
orm/gorp/app/workers.go
|
NewDbWorker
|
func NewDbWorker(db *DbGorp, workInfo DbWorkInfo, numWorkers int) (container *DbWorkerContainer) {
container = &DbWorkerContainer{
SharedWorker: SharedWorker{
InputChannel: make(chan interface{}, numWorkers),
OutputChannel: make(chan interface{}, numWorkers),
ControlChannel: make(chan func() (WorkerPhase, *DbWorker), numWorkers),
workInfo: workInfo,
},
NumWorkers: numWorkers,
Db: db,
StartWorkTimeout: 0,
LongWorkTimeout: 0,
}
return
}
|
go
|
func NewDbWorker(db *DbGorp, workInfo DbWorkInfo, numWorkers int) (container *DbWorkerContainer) {
container = &DbWorkerContainer{
SharedWorker: SharedWorker{
InputChannel: make(chan interface{}, numWorkers),
OutputChannel: make(chan interface{}, numWorkers),
ControlChannel: make(chan func() (WorkerPhase, *DbWorker), numWorkers),
workInfo: workInfo,
},
NumWorkers: numWorkers,
Db: db,
StartWorkTimeout: 0,
LongWorkTimeout: 0,
}
return
}
|
[
"func",
"NewDbWorker",
"(",
"db",
"*",
"DbGorp",
",",
"workInfo",
"DbWorkInfo",
",",
"numWorkers",
"int",
")",
"(",
"container",
"*",
"DbWorkerContainer",
")",
"{",
"container",
"=",
"&",
"DbWorkerContainer",
"{",
"SharedWorker",
":",
"SharedWorker",
"{",
"InputChannel",
":",
"make",
"(",
"chan",
"interface",
"{",
"}",
",",
"numWorkers",
")",
",",
"OutputChannel",
":",
"make",
"(",
"chan",
"interface",
"{",
"}",
",",
"numWorkers",
")",
",",
"ControlChannel",
":",
"make",
"(",
"chan",
"func",
"(",
")",
"(",
"WorkerPhase",
",",
"*",
"DbWorker",
")",
",",
"numWorkers",
")",
",",
"workInfo",
":",
"workInfo",
",",
"}",
",",
"NumWorkers",
":",
"numWorkers",
",",
"Db",
":",
"db",
",",
"StartWorkTimeout",
":",
"0",
",",
"LongWorkTimeout",
":",
"0",
",",
"}",
"\n",
"return",
"\n",
"}"
] |
// This creates a DbWorkerContainer with the number of working threads already started.
// Each working thread has their own database instance running.
|
[
"This",
"creates",
"a",
"DbWorkerContainer",
"with",
"the",
"number",
"of",
"working",
"threads",
"already",
"started",
".",
"Each",
"working",
"thread",
"has",
"their",
"own",
"database",
"instance",
"running",
"."
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L96-L111
|
16,119 |
revel/modules
|
orm/gorp/app/workers.go
|
startWorker
|
func startWorker(container *DbWorkerContainer, db *DbGorp, id int) {
newDb, _ := db.CloneDb(true)
worker := &DbWorker{
Db: newDb,
Id: id,
SharedData: map[string]interface{}{},
SharedWorker: SharedWorker{
workInfo: container.workInfo,
InputChannel: container.InputChannel,
OutputChannel: container.OutputChannel,
ControlChannel: container.ControlChannel,
},
}
// Close the database after worker has ended (Start returned
defer worker.Db.Close()
container.mutex.Lock()
container.Workers = append(container.Workers, worker)
container.mutex.Unlock()
// Only monitor jobs if Status function defined and a timeout is also defined
if container.LongWorkTimeout > 0 {
worker.TimeoutChannel = make(chan *timeoutInfo)
go worker.TimeInfo.start(worker.TimeoutChannel, container.LongWorkTimeout)
}
worker.start()
}
|
go
|
func startWorker(container *DbWorkerContainer, db *DbGorp, id int) {
newDb, _ := db.CloneDb(true)
worker := &DbWorker{
Db: newDb,
Id: id,
SharedData: map[string]interface{}{},
SharedWorker: SharedWorker{
workInfo: container.workInfo,
InputChannel: container.InputChannel,
OutputChannel: container.OutputChannel,
ControlChannel: container.ControlChannel,
},
}
// Close the database after worker has ended (Start returned
defer worker.Db.Close()
container.mutex.Lock()
container.Workers = append(container.Workers, worker)
container.mutex.Unlock()
// Only monitor jobs if Status function defined and a timeout is also defined
if container.LongWorkTimeout > 0 {
worker.TimeoutChannel = make(chan *timeoutInfo)
go worker.TimeInfo.start(worker.TimeoutChannel, container.LongWorkTimeout)
}
worker.start()
}
|
[
"func",
"startWorker",
"(",
"container",
"*",
"DbWorkerContainer",
",",
"db",
"*",
"DbGorp",
",",
"id",
"int",
")",
"{",
"newDb",
",",
"_",
":=",
"db",
".",
"CloneDb",
"(",
"true",
")",
"\n",
"worker",
":=",
"&",
"DbWorker",
"{",
"Db",
":",
"newDb",
",",
"Id",
":",
"id",
",",
"SharedData",
":",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
",",
"SharedWorker",
":",
"SharedWorker",
"{",
"workInfo",
":",
"container",
".",
"workInfo",
",",
"InputChannel",
":",
"container",
".",
"InputChannel",
",",
"OutputChannel",
":",
"container",
".",
"OutputChannel",
",",
"ControlChannel",
":",
"container",
".",
"ControlChannel",
",",
"}",
",",
"}",
"\n",
"// Close the database after worker has ended (Start returned",
"defer",
"worker",
".",
"Db",
".",
"Close",
"(",
")",
"\n",
"container",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"container",
".",
"Workers",
"=",
"append",
"(",
"container",
".",
"Workers",
",",
"worker",
")",
"\n",
"container",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"// Only monitor jobs if Status function defined and a timeout is also defined",
"if",
"container",
".",
"LongWorkTimeout",
">",
"0",
"{",
"worker",
".",
"TimeoutChannel",
"=",
"make",
"(",
"chan",
"*",
"timeoutInfo",
")",
"\n",
"go",
"worker",
".",
"TimeInfo",
".",
"start",
"(",
"worker",
".",
"TimeoutChannel",
",",
"container",
".",
"LongWorkTimeout",
")",
"\n",
"}",
"\n",
"worker",
".",
"start",
"(",
")",
"\n",
"}"
] |
// Called by using "go" to invoke, creates a DBWorker, and starts a watchdog channel
|
[
"Called",
"by",
"using",
"go",
"to",
"invoke",
"creates",
"a",
"DBWorker",
"and",
"starts",
"a",
"watchdog",
"channel"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L166-L190
|
16,120 |
revel/modules
|
orm/gorp/app/workers.go
|
start
|
func (worker *DbWorker) start() {
worker.workInfo.Status(Start, worker)
worker.ControlChannel <- func() (WorkerPhase, *DbWorker) { return Start, worker }
for job := range worker.InputChannel {
worker.invoke(job)
}
worker.workInfo.Status(Stop, worker)
worker.ControlChannel <- func() (WorkerPhase, *DbWorker) { return Stop, worker }
if worker.TimeoutChannel != nil {
close(worker.TimeoutChannel)
}
}
|
go
|
func (worker *DbWorker) start() {
worker.workInfo.Status(Start, worker)
worker.ControlChannel <- func() (WorkerPhase, *DbWorker) { return Start, worker }
for job := range worker.InputChannel {
worker.invoke(job)
}
worker.workInfo.Status(Stop, worker)
worker.ControlChannel <- func() (WorkerPhase, *DbWorker) { return Stop, worker }
if worker.TimeoutChannel != nil {
close(worker.TimeoutChannel)
}
}
|
[
"func",
"(",
"worker",
"*",
"DbWorker",
")",
"start",
"(",
")",
"{",
"worker",
".",
"workInfo",
".",
"Status",
"(",
"Start",
",",
"worker",
")",
"\n",
"worker",
".",
"ControlChannel",
"<-",
"func",
"(",
")",
"(",
"WorkerPhase",
",",
"*",
"DbWorker",
")",
"{",
"return",
"Start",
",",
"worker",
"}",
"\n",
"for",
"job",
":=",
"range",
"worker",
".",
"InputChannel",
"{",
"worker",
".",
"invoke",
"(",
"job",
")",
"\n",
"}",
"\n",
"worker",
".",
"workInfo",
".",
"Status",
"(",
"Stop",
",",
"worker",
")",
"\n",
"worker",
".",
"ControlChannel",
"<-",
"func",
"(",
")",
"(",
"WorkerPhase",
",",
"*",
"DbWorker",
")",
"{",
"return",
"Stop",
",",
"worker",
"}",
"\n",
"if",
"worker",
".",
"TimeoutChannel",
"!=",
"nil",
"{",
"close",
"(",
"worker",
".",
"TimeoutChannel",
")",
"\n",
"}",
"\n",
"}"
] |
// Starts the worker, continues running until inputchannel is closed
|
[
"Starts",
"the",
"worker",
"continues",
"running",
"until",
"inputchannel",
"is",
"closed"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L193-L204
|
16,121 |
revel/modules
|
orm/gorp/app/workers.go
|
invoke
|
func (worker *DbWorker) invoke(job interface{}) {
defer func() {
if err := recover(); err != nil {
trace := make([]byte, 1024)
count := runtime.Stack(trace, true)
moduleLogger.Error("Recover from panic: ", "error", err)
moduleLogger.Error("Stack", "size", count, "trace", string(trace))
}
}()
// Setup the timeout information
if worker.TimeoutChannel != nil {
worker.TimeInfo = &timeoutInfo{worker: worker, started: time.Now(), state: StartJob}
worker.TimeoutChannel <- worker.TimeInfo
}
worker.workInfo.Work(job, worker)
if worker.TimeoutChannel != nil {
worker.TimeInfo.state = EndJob
worker.TimeoutChannel <- worker.TimeInfo
}
}
|
go
|
func (worker *DbWorker) invoke(job interface{}) {
defer func() {
if err := recover(); err != nil {
trace := make([]byte, 1024)
count := runtime.Stack(trace, true)
moduleLogger.Error("Recover from panic: ", "error", err)
moduleLogger.Error("Stack", "size", count, "trace", string(trace))
}
}()
// Setup the timeout information
if worker.TimeoutChannel != nil {
worker.TimeInfo = &timeoutInfo{worker: worker, started: time.Now(), state: StartJob}
worker.TimeoutChannel <- worker.TimeInfo
}
worker.workInfo.Work(job, worker)
if worker.TimeoutChannel != nil {
worker.TimeInfo.state = EndJob
worker.TimeoutChannel <- worker.TimeInfo
}
}
|
[
"func",
"(",
"worker",
"*",
"DbWorker",
")",
"invoke",
"(",
"job",
"interface",
"{",
"}",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"recover",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"trace",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1024",
")",
"\n",
"count",
":=",
"runtime",
".",
"Stack",
"(",
"trace",
",",
"true",
")",
"\n",
"moduleLogger",
".",
"Error",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"moduleLogger",
".",
"Error",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"count",
",",
"\"",
"\"",
",",
"string",
"(",
"trace",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"// Setup the timeout information",
"if",
"worker",
".",
"TimeoutChannel",
"!=",
"nil",
"{",
"worker",
".",
"TimeInfo",
"=",
"&",
"timeoutInfo",
"{",
"worker",
":",
"worker",
",",
"started",
":",
"time",
".",
"Now",
"(",
")",
",",
"state",
":",
"StartJob",
"}",
"\n",
"worker",
".",
"TimeoutChannel",
"<-",
"worker",
".",
"TimeInfo",
"\n",
"}",
"\n",
"worker",
".",
"workInfo",
".",
"Work",
"(",
"job",
",",
"worker",
")",
"\n",
"if",
"worker",
".",
"TimeoutChannel",
"!=",
"nil",
"{",
"worker",
".",
"TimeInfo",
".",
"state",
"=",
"EndJob",
"\n",
"worker",
".",
"TimeoutChannel",
"<-",
"worker",
".",
"TimeInfo",
"\n",
"}",
"\n",
"}"
] |
// Wrapper to prevent panics from disturbing the channel
|
[
"Wrapper",
"to",
"prevent",
"panics",
"from",
"disturbing",
"the",
"channel"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L207-L226
|
16,122 |
revel/modules
|
orm/gorp/app/workers.go
|
MakeCallback
|
func MakeCallback(status func(phase WorkerPhase, worker *DbWorker), work func(value interface{}, worker *DbWorker)) DbWorkInfo {
return &DbCallbackImplied{StatusFn: status, WorkFn: work}
}
|
go
|
func MakeCallback(status func(phase WorkerPhase, worker *DbWorker), work func(value interface{}, worker *DbWorker)) DbWorkInfo {
return &DbCallbackImplied{StatusFn: status, WorkFn: work}
}
|
[
"func",
"MakeCallback",
"(",
"status",
"func",
"(",
"phase",
"WorkerPhase",
",",
"worker",
"*",
"DbWorker",
")",
",",
"work",
"func",
"(",
"value",
"interface",
"{",
"}",
",",
"worker",
"*",
"DbWorker",
")",
")",
"DbWorkInfo",
"{",
"return",
"&",
"DbCallbackImplied",
"{",
"StatusFn",
":",
"status",
",",
"WorkFn",
":",
"work",
"}",
"\n",
"}"
] |
// A function to return an object that is a valid DbCallback
|
[
"A",
"function",
"to",
"return",
"an",
"object",
"that",
"is",
"a",
"valid",
"DbCallback"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L229-L231
|
16,123 |
revel/modules
|
orm/gorp/app/workers.go
|
Status
|
func (dbCallback *DbCallbackImplied) Status(phase WorkerPhase, worker *DbWorker) {
if dbCallback.StatusFn != nil {
dbCallback.StatusFn(phase, worker)
}
}
|
go
|
func (dbCallback *DbCallbackImplied) Status(phase WorkerPhase, worker *DbWorker) {
if dbCallback.StatusFn != nil {
dbCallback.StatusFn(phase, worker)
}
}
|
[
"func",
"(",
"dbCallback",
"*",
"DbCallbackImplied",
")",
"Status",
"(",
"phase",
"WorkerPhase",
",",
"worker",
"*",
"DbWorker",
")",
"{",
"if",
"dbCallback",
".",
"StatusFn",
"!=",
"nil",
"{",
"dbCallback",
".",
"StatusFn",
"(",
"phase",
",",
"worker",
")",
"\n",
"}",
"\n",
"}"
] |
// Call the status function if available
|
[
"Call",
"the",
"status",
"function",
"if",
"available"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L234-L238
|
16,124 |
revel/modules
|
orm/gorp/app/workers.go
|
Work
|
func (dbCallback *DbCallbackImplied) Work(value interface{}, worker *DbWorker) {
dbCallback.WorkFn(value, worker)
}
|
go
|
func (dbCallback *DbCallbackImplied) Work(value interface{}, worker *DbWorker) {
dbCallback.WorkFn(value, worker)
}
|
[
"func",
"(",
"dbCallback",
"*",
"DbCallbackImplied",
")",
"Work",
"(",
"value",
"interface",
"{",
"}",
",",
"worker",
"*",
"DbWorker",
")",
"{",
"dbCallback",
".",
"WorkFn",
"(",
"value",
",",
"worker",
")",
"\n",
"}"
] |
// Calls the work function
|
[
"Calls",
"the",
"work",
"function"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L241-L243
|
16,125 |
revel/modules
|
orm/gorp/app/workers.go
|
start
|
func (_ *timeoutInfo) start(TimeoutChannel chan *timeoutInfo, timeout int64) {
for j := range TimeoutChannel {
j.started = time.Now()
j.state = StartJob
j.worker.workInfo.Status(j.state, j.worker)
for {
select {
case complete, ok := <-TimeoutChannel:
if !ok {
// Channel closed returning...
return
}
// Received new State, record and loop
complete.worker.workInfo.Status(complete.state, complete.worker)
break
case <-time.After(time.Second * time.Duration(timeout)):
j.worker.workInfo.Status(JobLongrunning, j.worker)
}
}
}
}
|
go
|
func (_ *timeoutInfo) start(TimeoutChannel chan *timeoutInfo, timeout int64) {
for j := range TimeoutChannel {
j.started = time.Now()
j.state = StartJob
j.worker.workInfo.Status(j.state, j.worker)
for {
select {
case complete, ok := <-TimeoutChannel:
if !ok {
// Channel closed returning...
return
}
// Received new State, record and loop
complete.worker.workInfo.Status(complete.state, complete.worker)
break
case <-time.After(time.Second * time.Duration(timeout)):
j.worker.workInfo.Status(JobLongrunning, j.worker)
}
}
}
}
|
[
"func",
"(",
"_",
"*",
"timeoutInfo",
")",
"start",
"(",
"TimeoutChannel",
"chan",
"*",
"timeoutInfo",
",",
"timeout",
"int64",
")",
"{",
"for",
"j",
":=",
"range",
"TimeoutChannel",
"{",
"j",
".",
"started",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"j",
".",
"state",
"=",
"StartJob",
"\n",
"j",
".",
"worker",
".",
"workInfo",
".",
"Status",
"(",
"j",
".",
"state",
",",
"j",
".",
"worker",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"complete",
",",
"ok",
":=",
"<-",
"TimeoutChannel",
":",
"if",
"!",
"ok",
"{",
"// Channel closed returning...",
"return",
"\n",
"}",
"\n",
"// Received new State, record and loop",
"complete",
".",
"worker",
".",
"workInfo",
".",
"Status",
"(",
"complete",
".",
"state",
",",
"complete",
".",
"worker",
")",
"\n",
"break",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"time",
".",
"Second",
"*",
"time",
".",
"Duration",
"(",
"timeout",
")",
")",
":",
"j",
".",
"worker",
".",
"workInfo",
".",
"Status",
"(",
"JobLongrunning",
",",
"j",
".",
"worker",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
//Starts the timeout worker
|
[
"Starts",
"the",
"timeout",
"worker"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/workers.go#L246-L266
|
16,126 |
revel/modules
|
orm/gorp/app/dbgorp.go
|
CloneDb
|
func (dbGorp *DbGorp) CloneDb(open bool) (newDb *DbGorp, err error) {
dbInfo := *dbGorp.Info
newDb = &DbGorp{Info: &dbInfo}
newDb.dbInitFn = dbGorp.dbInitFn
err = newDb.InitDb(open)
return
}
|
go
|
func (dbGorp *DbGorp) CloneDb(open bool) (newDb *DbGorp, err error) {
dbInfo := *dbGorp.Info
newDb = &DbGorp{Info: &dbInfo}
newDb.dbInitFn = dbGorp.dbInitFn
err = newDb.InitDb(open)
return
}
|
[
"func",
"(",
"dbGorp",
"*",
"DbGorp",
")",
"CloneDb",
"(",
"open",
"bool",
")",
"(",
"newDb",
"*",
"DbGorp",
",",
"err",
"error",
")",
"{",
"dbInfo",
":=",
"*",
"dbGorp",
".",
"Info",
"\n",
"newDb",
"=",
"&",
"DbGorp",
"{",
"Info",
":",
"&",
"dbInfo",
"}",
"\n",
"newDb",
".",
"dbInitFn",
"=",
"dbGorp",
".",
"dbInitFn",
"\n",
"err",
"=",
"newDb",
".",
"InitDb",
"(",
"open",
")",
"\n\n",
"return",
"\n",
"}"
] |
// Create a new database connection and open it from this one
|
[
"Create",
"a",
"new",
"database",
"connection",
"and",
"open",
"it",
"from",
"this",
"one"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/dbgorp.go#L81-L88
|
16,127 |
revel/modules
|
orm/gorp/app/dbgorp.go
|
dbInit
|
func (dbGorp *DbGorp) dbInit() (err error) {
if dbGorp.dbInitFn != nil {
err = dbGorp.dbInitFn(dbGorp)
}
return
}
|
go
|
func (dbGorp *DbGorp) dbInit() (err error) {
if dbGorp.dbInitFn != nil {
err = dbGorp.dbInitFn(dbGorp)
}
return
}
|
[
"func",
"(",
"dbGorp",
"*",
"DbGorp",
")",
"dbInit",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"dbGorp",
".",
"dbInitFn",
"!=",
"nil",
"{",
"err",
"=",
"dbGorp",
".",
"dbInitFn",
"(",
"dbGorp",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Called to perform table registration and anything else that needs to be done on a new connection
|
[
"Called",
"to",
"perform",
"table",
"registration",
"and",
"anything",
"else",
"that",
"needs",
"to",
"be",
"done",
"on",
"a",
"new",
"connection"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/dbgorp.go#L109-L114
|
16,128 |
revel/modules
|
orm/gorp/app/dbgorp.go
|
SetDbInit
|
func (dbGorp *DbGorp) SetDbInit(dbInitFn func(dbMap *DbGorp) error) (err error) {
dbGorp.dbInitFn = dbInitFn
return dbGorp.dbInit()
}
|
go
|
func (dbGorp *DbGorp) SetDbInit(dbInitFn func(dbMap *DbGorp) error) (err error) {
dbGorp.dbInitFn = dbInitFn
return dbGorp.dbInit()
}
|
[
"func",
"(",
"dbGorp",
"*",
"DbGorp",
")",
"SetDbInit",
"(",
"dbInitFn",
"func",
"(",
"dbMap",
"*",
"DbGorp",
")",
"error",
")",
"(",
"err",
"error",
")",
"{",
"dbGorp",
".",
"dbInitFn",
"=",
"dbInitFn",
"\n",
"return",
"dbGorp",
".",
"dbInit",
"(",
")",
"\n",
"}"
] |
// Used to specifiy the init function to call when database is initialized
// Calls the init function immediately
|
[
"Used",
"to",
"specifiy",
"the",
"init",
"function",
"to",
"call",
"when",
"database",
"is",
"initialized",
"Calls",
"the",
"init",
"function",
"immediately"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorp/app/dbgorp.go#L118-L121
|
16,129 |
revel/modules
|
template-engine/ace/app/controllers/ace.go
|
RenderAceTemplate
|
func (c *AceController) RenderAceTemplate(base, inner string) revel.Result {
c.ViewArgs["ace-inner"] = inner
return c.RenderTemplate(base)
}
|
go
|
func (c *AceController) RenderAceTemplate(base, inner string) revel.Result {
c.ViewArgs["ace-inner"] = inner
return c.RenderTemplate(base)
}
|
[
"func",
"(",
"c",
"*",
"AceController",
")",
"RenderAceTemplate",
"(",
"base",
",",
"inner",
"string",
")",
"revel",
".",
"Result",
"{",
"c",
".",
"ViewArgs",
"[",
"\"",
"\"",
"]",
"=",
"inner",
"\n",
"return",
"c",
".",
"RenderTemplate",
"(",
"base",
")",
"\n",
"}"
] |
// Called to render the ace template inner
|
[
"Called",
"to",
"render",
"the",
"ace",
"template",
"inner"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/template-engine/ace/app/controllers/ace.go#L10-L13
|
16,130 |
revel/modules
|
orm/gorm/app/controllers/gorm.go
|
Begin
|
func (c *TxnController) Begin() revel.Result {
txn := gormdb.DB.Begin()
if txn.Error != nil {
c.Log.Panic("Transaction begine error", "error", txn.Error)
}
c.Txn = txn
return nil
}
|
go
|
func (c *TxnController) Begin() revel.Result {
txn := gormdb.DB.Begin()
if txn.Error != nil {
c.Log.Panic("Transaction begine error", "error", txn.Error)
}
c.Txn = txn
return nil
}
|
[
"func",
"(",
"c",
"*",
"TxnController",
")",
"Begin",
"(",
")",
"revel",
".",
"Result",
"{",
"txn",
":=",
"gormdb",
".",
"DB",
".",
"Begin",
"(",
")",
"\n",
"if",
"txn",
".",
"Error",
"!=",
"nil",
"{",
"c",
".",
"Log",
".",
"Panic",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"txn",
".",
"Error",
")",
"\n",
"}",
"\n\n",
"c",
".",
"Txn",
"=",
"txn",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Begin begins a DB transaction
|
[
"Begin",
"begins",
"a",
"DB",
"transaction"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorm/app/controllers/gorm.go#L30-L39
|
16,131 |
revel/modules
|
orm/gorm/app/controllers/gorm.go
|
Commit
|
func (c *TxnController) Commit() revel.Result {
if c.Txn == nil {
return nil
}
c.Txn.Commit()
if c.Txn.Error != nil && c.Txn.Error != sql.ErrTxDone {
fmt.Println(c.Txn.Error)
panic(c.Txn.Error)
}
c.Txn = nil
return nil
}
|
go
|
func (c *TxnController) Commit() revel.Result {
if c.Txn == nil {
return nil
}
c.Txn.Commit()
if c.Txn.Error != nil && c.Txn.Error != sql.ErrTxDone {
fmt.Println(c.Txn.Error)
panic(c.Txn.Error)
}
c.Txn = nil
return nil
}
|
[
"func",
"(",
"c",
"*",
"TxnController",
")",
"Commit",
"(",
")",
"revel",
".",
"Result",
"{",
"if",
"c",
".",
"Txn",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"c",
".",
"Txn",
".",
"Commit",
"(",
")",
"\n",
"if",
"c",
".",
"Txn",
".",
"Error",
"!=",
"nil",
"&&",
"c",
".",
"Txn",
".",
"Error",
"!=",
"sql",
".",
"ErrTxDone",
"{",
"fmt",
".",
"Println",
"(",
"c",
".",
"Txn",
".",
"Error",
")",
"\n",
"panic",
"(",
"c",
".",
"Txn",
".",
"Error",
")",
"\n",
"}",
"\n\n",
"c",
".",
"Txn",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Commit commits the database transation
|
[
"Commit",
"commits",
"the",
"database",
"transation"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/orm/gorm/app/controllers/gorm.go#L42-L55
|
16,132 |
revel/modules
|
server-engine/newrelic/server-newrelic.go
|
NewRelicFilter
|
func NewRelicFilter(c *revel.Controller, fc []revel.Filter) {
if nr, ok := revel.CurrentEngine.Engine().(*ServerNewRelic); ok {
if nr.NewRelicApp != nil {
txn := nr.NewRelicApp.StartTransaction(c.Action,
c.Response.Out.Server.(*revel.GoResponse).Original,
c.Request.In.(*revel.GoRequest).Original)
defer txn.End()
} else {
serverLog.Error("Newrelic application not initialized before filter called")
}
}
fc[0](c, fc[1:])
}
|
go
|
func NewRelicFilter(c *revel.Controller, fc []revel.Filter) {
if nr, ok := revel.CurrentEngine.Engine().(*ServerNewRelic); ok {
if nr.NewRelicApp != nil {
txn := nr.NewRelicApp.StartTransaction(c.Action,
c.Response.Out.Server.(*revel.GoResponse).Original,
c.Request.In.(*revel.GoRequest).Original)
defer txn.End()
} else {
serverLog.Error("Newrelic application not initialized before filter called")
}
}
fc[0](c, fc[1:])
}
|
[
"func",
"NewRelicFilter",
"(",
"c",
"*",
"revel",
".",
"Controller",
",",
"fc",
"[",
"]",
"revel",
".",
"Filter",
")",
"{",
"if",
"nr",
",",
"ok",
":=",
"revel",
".",
"CurrentEngine",
".",
"Engine",
"(",
")",
".",
"(",
"*",
"ServerNewRelic",
")",
";",
"ok",
"{",
"if",
"nr",
".",
"NewRelicApp",
"!=",
"nil",
"{",
"txn",
":=",
"nr",
".",
"NewRelicApp",
".",
"StartTransaction",
"(",
"c",
".",
"Action",
",",
"c",
".",
"Response",
".",
"Out",
".",
"Server",
".",
"(",
"*",
"revel",
".",
"GoResponse",
")",
".",
"Original",
",",
"c",
".",
"Request",
".",
"In",
".",
"(",
"*",
"revel",
".",
"GoRequest",
")",
".",
"Original",
")",
"\n",
"defer",
"txn",
".",
"End",
"(",
")",
"\n",
"}",
"else",
"{",
"serverLog",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"fc",
"[",
"0",
"]",
"(",
"c",
",",
"fc",
"[",
"1",
":",
"]",
")",
"\n",
"}"
] |
// This is a simplistic example of setting up a filter to record all events for the
// webserver as transactions
|
[
"This",
"is",
"a",
"simplistic",
"example",
"of",
"setting",
"up",
"a",
"filter",
"to",
"record",
"all",
"events",
"for",
"the",
"webserver",
"as",
"transactions"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/server-engine/newrelic/server-newrelic.go#L79-L92
|
16,133 |
revel/modules
|
static/app/controllers/static.go
|
ServeDir
|
func (c Static) ServeDir(prefix, filepath string) revel.Result {
// Fix for #503.
prefix = c.Params.Fixed.Get("prefix")
if prefix == "" {
return c.NotFound("")
}
return serve(c, prefix, filepath, true)
}
|
go
|
func (c Static) ServeDir(prefix, filepath string) revel.Result {
// Fix for #503.
prefix = c.Params.Fixed.Get("prefix")
if prefix == "" {
return c.NotFound("")
}
return serve(c, prefix, filepath, true)
}
|
[
"func",
"(",
"c",
"Static",
")",
"ServeDir",
"(",
"prefix",
",",
"filepath",
"string",
")",
"revel",
".",
"Result",
"{",
"// Fix for #503.",
"prefix",
"=",
"c",
".",
"Params",
".",
"Fixed",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"prefix",
"==",
"\"",
"\"",
"{",
"return",
"c",
".",
"NotFound",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"serve",
"(",
"c",
",",
"prefix",
",",
"filepath",
",",
"true",
")",
"\n",
"}"
] |
// This function serves out the directory as a browseable folder
|
[
"This",
"function",
"serves",
"out",
"the",
"directory",
"as",
"a",
"browseable",
"folder"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/static/app/controllers/static.go#L85-L93
|
16,134 |
revel/modules
|
static/app/controllers/static.go
|
processDir
|
func (c *Static) processDir(fullPath, basePath string) (args map[string]interface{}, err error) {
dirName := fpath.Base(fullPath)
args = map[string]interface{}{"dirName": dirName}
// Walk the folder showing up and down links
dirFiles := []model.FileInformation{}
symLinkPath, e := fpath.EvalSymlinks(fullPath)
if e != nil {
return args, e
}
// Get directory contents
files, e := ioutil.ReadDir(fullPath)
if e != nil {
return nil, e
}
if fullPath != basePath {
fileInfo := model.FileInformation{Icon: UP_DIR_ICON, Name: c.Message("static\\parent directory"), Relative: "../"}
dirFiles = append(dirFiles, fileInfo)
}
for _, f := range files {
fileInfo := model.FileInformation{Name: f.Name()}
if f.IsDir() {
fileInfo.Icon = DIR_ICON
// Check that it is not a symnlink
realFullPath, _ := fpath.EvalSymlinks(fpath.Join(fullPath, f.Name()))
if strings.HasPrefix(realFullPath, symLinkPath) {
// Valid to drill into
fileInfo.Relative = f.Name() + "/"
}
} else {
fileInfo.Icon = FILE_ICON
size := "bytes"
divider := int64(1)
fileInfo.Size = f.Size()
for x := 0; fileInfo.Size > byteSizeList[x][1].(int64); x++ {
size = byteSizeList[x][0].(string)
divider = byteSizeList[x][1].(int64)
}
fileInfo.Size = fileInfo.Size / divider
fileInfo.SizeType = size
fileInfo.NiceSize = fmt.Sprintf("%0.1d %s", fileInfo.Size, size)
fileInfo.Relative = fileInfo.Name
}
modified := f.ModTime()
fileInfo.Modified = &modified
dirFiles = append(dirFiles, fileInfo)
}
args["content"] = dirFiles
args["count"] = len(dirFiles)
args["dateformat"] = revel.Config.StringDefault("static.dateformat", "2006-01-02 15:04:05 MST")
return
}
|
go
|
func (c *Static) processDir(fullPath, basePath string) (args map[string]interface{}, err error) {
dirName := fpath.Base(fullPath)
args = map[string]interface{}{"dirName": dirName}
// Walk the folder showing up and down links
dirFiles := []model.FileInformation{}
symLinkPath, e := fpath.EvalSymlinks(fullPath)
if e != nil {
return args, e
}
// Get directory contents
files, e := ioutil.ReadDir(fullPath)
if e != nil {
return nil, e
}
if fullPath != basePath {
fileInfo := model.FileInformation{Icon: UP_DIR_ICON, Name: c.Message("static\\parent directory"), Relative: "../"}
dirFiles = append(dirFiles, fileInfo)
}
for _, f := range files {
fileInfo := model.FileInformation{Name: f.Name()}
if f.IsDir() {
fileInfo.Icon = DIR_ICON
// Check that it is not a symnlink
realFullPath, _ := fpath.EvalSymlinks(fpath.Join(fullPath, f.Name()))
if strings.HasPrefix(realFullPath, symLinkPath) {
// Valid to drill into
fileInfo.Relative = f.Name() + "/"
}
} else {
fileInfo.Icon = FILE_ICON
size := "bytes"
divider := int64(1)
fileInfo.Size = f.Size()
for x := 0; fileInfo.Size > byteSizeList[x][1].(int64); x++ {
size = byteSizeList[x][0].(string)
divider = byteSizeList[x][1].(int64)
}
fileInfo.Size = fileInfo.Size / divider
fileInfo.SizeType = size
fileInfo.NiceSize = fmt.Sprintf("%0.1d %s", fileInfo.Size, size)
fileInfo.Relative = fileInfo.Name
}
modified := f.ModTime()
fileInfo.Modified = &modified
dirFiles = append(dirFiles, fileInfo)
}
args["content"] = dirFiles
args["count"] = len(dirFiles)
args["dateformat"] = revel.Config.StringDefault("static.dateformat", "2006-01-02 15:04:05 MST")
return
}
|
[
"func",
"(",
"c",
"*",
"Static",
")",
"processDir",
"(",
"fullPath",
",",
"basePath",
"string",
")",
"(",
"args",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"dirName",
":=",
"fpath",
".",
"Base",
"(",
"fullPath",
")",
"\n",
"args",
"=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"dirName",
"}",
"\n",
"// Walk the folder showing up and down links",
"dirFiles",
":=",
"[",
"]",
"model",
".",
"FileInformation",
"{",
"}",
"\n",
"symLinkPath",
",",
"e",
":=",
"fpath",
".",
"EvalSymlinks",
"(",
"fullPath",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"return",
"args",
",",
"e",
"\n",
"}",
"\n\n",
"// Get directory contents",
"files",
",",
"e",
":=",
"ioutil",
".",
"ReadDir",
"(",
"fullPath",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"return",
"nil",
",",
"e",
"\n",
"}",
"\n\n",
"if",
"fullPath",
"!=",
"basePath",
"{",
"fileInfo",
":=",
"model",
".",
"FileInformation",
"{",
"Icon",
":",
"UP_DIR_ICON",
",",
"Name",
":",
"c",
".",
"Message",
"(",
"\"",
"\\\\",
"\"",
")",
",",
"Relative",
":",
"\"",
"\"",
"}",
"\n",
"dirFiles",
"=",
"append",
"(",
"dirFiles",
",",
"fileInfo",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"files",
"{",
"fileInfo",
":=",
"model",
".",
"FileInformation",
"{",
"Name",
":",
"f",
".",
"Name",
"(",
")",
"}",
"\n",
"if",
"f",
".",
"IsDir",
"(",
")",
"{",
"fileInfo",
".",
"Icon",
"=",
"DIR_ICON",
"\n",
"// Check that it is not a symnlink",
"realFullPath",
",",
"_",
":=",
"fpath",
".",
"EvalSymlinks",
"(",
"fpath",
".",
"Join",
"(",
"fullPath",
",",
"f",
".",
"Name",
"(",
")",
")",
")",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"realFullPath",
",",
"symLinkPath",
")",
"{",
"// Valid to drill into",
"fileInfo",
".",
"Relative",
"=",
"f",
".",
"Name",
"(",
")",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"else",
"{",
"fileInfo",
".",
"Icon",
"=",
"FILE_ICON",
"\n",
"size",
":=",
"\"",
"\"",
"\n",
"divider",
":=",
"int64",
"(",
"1",
")",
"\n",
"fileInfo",
".",
"Size",
"=",
"f",
".",
"Size",
"(",
")",
"\n",
"for",
"x",
":=",
"0",
";",
"fileInfo",
".",
"Size",
">",
"byteSizeList",
"[",
"x",
"]",
"[",
"1",
"]",
".",
"(",
"int64",
")",
";",
"x",
"++",
"{",
"size",
"=",
"byteSizeList",
"[",
"x",
"]",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"divider",
"=",
"byteSizeList",
"[",
"x",
"]",
"[",
"1",
"]",
".",
"(",
"int64",
")",
"\n",
"}",
"\n",
"fileInfo",
".",
"Size",
"=",
"fileInfo",
".",
"Size",
"/",
"divider",
"\n",
"fileInfo",
".",
"SizeType",
"=",
"size",
"\n",
"fileInfo",
".",
"NiceSize",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"fileInfo",
".",
"Size",
",",
"size",
")",
"\n",
"fileInfo",
".",
"Relative",
"=",
"fileInfo",
".",
"Name",
"\n",
"}",
"\n",
"modified",
":=",
"f",
".",
"ModTime",
"(",
")",
"\n",
"fileInfo",
".",
"Modified",
"=",
"&",
"modified",
"\n",
"dirFiles",
"=",
"append",
"(",
"dirFiles",
",",
"fileInfo",
")",
"\n",
"}",
"\n",
"args",
"[",
"\"",
"\"",
"]",
"=",
"dirFiles",
"\n",
"args",
"[",
"\"",
"\"",
"]",
"=",
"len",
"(",
"dirFiles",
")",
"\n",
"args",
"[",
"\"",
"\"",
"]",
"=",
"revel",
".",
"Config",
".",
"StringDefault",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}"
] |
// Process a directory create a list of objects to be rendered representing the data for the directory
|
[
"Process",
"a",
"directory",
"create",
"a",
"list",
"of",
"objects",
"to",
"be",
"rendered",
"representing",
"the",
"data",
"for",
"the",
"directory"
] |
2737bfdaa8c41da68eae12bb18f7279b9f156048
|
https://github.com/revel/modules/blob/2737bfdaa8c41da68eae12bb18f7279b9f156048/static/app/controllers/static.go#L213-L265
|
16,135 |
cloudfoundry/bosh-s3cli
|
config/config.go
|
S3Endpoint
|
func (c *S3Cli) S3Endpoint() string {
if c.Host == "" {
return ""
}
if c.Port != 0 {
return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
return c.Host
}
|
go
|
func (c *S3Cli) S3Endpoint() string {
if c.Host == "" {
return ""
}
if c.Port != 0 {
return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
return c.Host
}
|
[
"func",
"(",
"c",
"*",
"S3Cli",
")",
"S3Endpoint",
"(",
")",
"string",
"{",
"if",
"c",
".",
"Host",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"c",
".",
"Port",
"!=",
"0",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"Host",
",",
"c",
".",
"Port",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"Host",
"\n",
"}"
] |
// S3Endpoint returns the S3 URI to use if custom host information has been provided
|
[
"S3Endpoint",
"returns",
"the",
"S3",
"URI",
"to",
"use",
"if",
"custom",
"host",
"information",
"has",
"been",
"provided"
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/config/config.go#L194-L202
|
16,136 |
cloudfoundry/bosh-s3cli
|
integration/assertions.go
|
AssertPutOptionsApplied
|
func AssertPutOptionsApplied(s3CLIPath string, cfg *config.S3Cli) {
expectedString := GenerateRandomString()
s3Filename := GenerateRandomString()
configPath := MakeConfigFile(cfg)
defer func() { _ = os.Remove(configPath) }()
contentFile := MakeContentFile(expectedString)
defer func() { _ = os.Remove(contentFile) }()
configFile, err := os.Open(configPath)
Expect(err).ToNot(HaveOccurred())
s3CLISession, err := RunS3CLI(s3CLIPath, configPath, "put", contentFile, s3Filename)
s3Config, err := config.NewFromReader(configFile)
Expect(err).ToNot(HaveOccurred())
client, _ := client.NewSDK(s3Config)
resp, err := client.HeadObject(&s3.HeadObjectInput{
Bucket: aws.String(cfg.BucketName),
Key: aws.String(s3Filename),
})
Expect(err).ToNot(HaveOccurred())
Expect(s3CLISession.ExitCode()).To(BeZero())
if cfg.ServerSideEncryption == "" {
Expect(resp.ServerSideEncryption).To(BeNil())
} else {
Expect(*resp.ServerSideEncryption).To(Equal(cfg.ServerSideEncryption))
}
}
|
go
|
func AssertPutOptionsApplied(s3CLIPath string, cfg *config.S3Cli) {
expectedString := GenerateRandomString()
s3Filename := GenerateRandomString()
configPath := MakeConfigFile(cfg)
defer func() { _ = os.Remove(configPath) }()
contentFile := MakeContentFile(expectedString)
defer func() { _ = os.Remove(contentFile) }()
configFile, err := os.Open(configPath)
Expect(err).ToNot(HaveOccurred())
s3CLISession, err := RunS3CLI(s3CLIPath, configPath, "put", contentFile, s3Filename)
s3Config, err := config.NewFromReader(configFile)
Expect(err).ToNot(HaveOccurred())
client, _ := client.NewSDK(s3Config)
resp, err := client.HeadObject(&s3.HeadObjectInput{
Bucket: aws.String(cfg.BucketName),
Key: aws.String(s3Filename),
})
Expect(err).ToNot(HaveOccurred())
Expect(s3CLISession.ExitCode()).To(BeZero())
if cfg.ServerSideEncryption == "" {
Expect(resp.ServerSideEncryption).To(BeNil())
} else {
Expect(*resp.ServerSideEncryption).To(Equal(cfg.ServerSideEncryption))
}
}
|
[
"func",
"AssertPutOptionsApplied",
"(",
"s3CLIPath",
"string",
",",
"cfg",
"*",
"config",
".",
"S3Cli",
")",
"{",
"expectedString",
":=",
"GenerateRandomString",
"(",
")",
"\n",
"s3Filename",
":=",
"GenerateRandomString",
"(",
")",
"\n\n",
"configPath",
":=",
"MakeConfigFile",
"(",
"cfg",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"_",
"=",
"os",
".",
"Remove",
"(",
"configPath",
")",
"}",
"(",
")",
"\n\n",
"contentFile",
":=",
"MakeContentFile",
"(",
"expectedString",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"_",
"=",
"os",
".",
"Remove",
"(",
"contentFile",
")",
"}",
"(",
")",
"\n\n",
"configFile",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"configPath",
")",
"\n",
"Expect",
"(",
"err",
")",
".",
"ToNot",
"(",
"HaveOccurred",
"(",
")",
")",
"\n\n",
"s3CLISession",
",",
"err",
":=",
"RunS3CLI",
"(",
"s3CLIPath",
",",
"configPath",
",",
"\"",
"\"",
",",
"contentFile",
",",
"s3Filename",
")",
"\n\n",
"s3Config",
",",
"err",
":=",
"config",
".",
"NewFromReader",
"(",
"configFile",
")",
"\n",
"Expect",
"(",
"err",
")",
".",
"ToNot",
"(",
"HaveOccurred",
"(",
")",
")",
"\n\n",
"client",
",",
"_",
":=",
"client",
".",
"NewSDK",
"(",
"s3Config",
")",
"\n",
"resp",
",",
"err",
":=",
"client",
".",
"HeadObject",
"(",
"&",
"s3",
".",
"HeadObjectInput",
"{",
"Bucket",
":",
"aws",
".",
"String",
"(",
"cfg",
".",
"BucketName",
")",
",",
"Key",
":",
"aws",
".",
"String",
"(",
"s3Filename",
")",
",",
"}",
")",
"\n",
"Expect",
"(",
"err",
")",
".",
"ToNot",
"(",
"HaveOccurred",
"(",
")",
")",
"\n",
"Expect",
"(",
"s3CLISession",
".",
"ExitCode",
"(",
")",
")",
".",
"To",
"(",
"BeZero",
"(",
")",
")",
"\n\n",
"if",
"cfg",
".",
"ServerSideEncryption",
"==",
"\"",
"\"",
"{",
"Expect",
"(",
"resp",
".",
"ServerSideEncryption",
")",
".",
"To",
"(",
"BeNil",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"Expect",
"(",
"*",
"resp",
".",
"ServerSideEncryption",
")",
".",
"To",
"(",
"Equal",
"(",
"cfg",
".",
"ServerSideEncryption",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// AssertPutOptionsApplied asserts that `s3cli put` uploads files with
// the requested encryption options
|
[
"AssertPutOptionsApplied",
"asserts",
"that",
"s3cli",
"put",
"uploads",
"files",
"with",
"the",
"requested",
"encryption",
"options"
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/integration/assertions.go#L118-L149
|
16,137 |
cloudfoundry/bosh-s3cli
|
integration/assertions.go
|
AssertGetNonexistentFails
|
func AssertGetNonexistentFails(s3CLIPath string, cfg *config.S3Cli) {
configPath := MakeConfigFile(cfg)
defer func() { _ = os.Remove(configPath) }()
s3CLISession, err := RunS3CLI(s3CLIPath, configPath, "get", "non-existent-file", "/dev/null")
Expect(err).ToNot(HaveOccurred())
Expect(s3CLISession.ExitCode()).ToNot(BeZero())
Expect(s3CLISession.Err.Contents()).To(ContainSubstring("NoSuchKey"))
}
|
go
|
func AssertGetNonexistentFails(s3CLIPath string, cfg *config.S3Cli) {
configPath := MakeConfigFile(cfg)
defer func() { _ = os.Remove(configPath) }()
s3CLISession, err := RunS3CLI(s3CLIPath, configPath, "get", "non-existent-file", "/dev/null")
Expect(err).ToNot(HaveOccurred())
Expect(s3CLISession.ExitCode()).ToNot(BeZero())
Expect(s3CLISession.Err.Contents()).To(ContainSubstring("NoSuchKey"))
}
|
[
"func",
"AssertGetNonexistentFails",
"(",
"s3CLIPath",
"string",
",",
"cfg",
"*",
"config",
".",
"S3Cli",
")",
"{",
"configPath",
":=",
"MakeConfigFile",
"(",
"cfg",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"_",
"=",
"os",
".",
"Remove",
"(",
"configPath",
")",
"}",
"(",
")",
"\n\n",
"s3CLISession",
",",
"err",
":=",
"RunS3CLI",
"(",
"s3CLIPath",
",",
"configPath",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"Expect",
"(",
"err",
")",
".",
"ToNot",
"(",
"HaveOccurred",
"(",
")",
")",
"\n",
"Expect",
"(",
"s3CLISession",
".",
"ExitCode",
"(",
")",
")",
".",
"ToNot",
"(",
"BeZero",
"(",
")",
")",
"\n",
"Expect",
"(",
"s3CLISession",
".",
"Err",
".",
"Contents",
"(",
")",
")",
".",
"To",
"(",
"ContainSubstring",
"(",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// AssertGetNonexistentFails asserts that `s3cli get` on a non-existent object
// will fail
|
[
"AssertGetNonexistentFails",
"asserts",
"that",
"s3cli",
"get",
"on",
"a",
"non",
"-",
"existent",
"object",
"will",
"fail"
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/integration/assertions.go#L153-L161
|
16,138 |
cloudfoundry/bosh-s3cli
|
client/client.go
|
New
|
func New(s3Client *s3.S3, s3cliConfig *config.S3Cli) (S3Blobstore, error) {
return S3Blobstore{s3Client: s3Client, s3cliConfig: s3cliConfig}, nil
}
|
go
|
func New(s3Client *s3.S3, s3cliConfig *config.S3Cli) (S3Blobstore, error) {
return S3Blobstore{s3Client: s3Client, s3cliConfig: s3cliConfig}, nil
}
|
[
"func",
"New",
"(",
"s3Client",
"*",
"s3",
".",
"S3",
",",
"s3cliConfig",
"*",
"config",
".",
"S3Cli",
")",
"(",
"S3Blobstore",
",",
"error",
")",
"{",
"return",
"S3Blobstore",
"{",
"s3Client",
":",
"s3Client",
",",
"s3cliConfig",
":",
"s3cliConfig",
"}",
",",
"nil",
"\n",
"}"
] |
// New returns a BlobstoreClient if the configuration file backing configFile is valid
|
[
"New",
"returns",
"a",
"BlobstoreClient",
"if",
"the",
"configuration",
"file",
"backing",
"configFile",
"is",
"valid"
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/client/client.go#L28-L30
|
16,139 |
cloudfoundry/bosh-s3cli
|
client/client.go
|
Get
|
func (client *S3Blobstore) Get(src string, dest io.WriterAt) error {
downloader := s3manager.NewDownloaderWithClient(client.s3Client)
_, err := downloader.Download(dest, &s3.GetObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(src),
})
if err != nil {
return err
}
return nil
}
|
go
|
func (client *S3Blobstore) Get(src string, dest io.WriterAt) error {
downloader := s3manager.NewDownloaderWithClient(client.s3Client)
_, err := downloader.Download(dest, &s3.GetObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(src),
})
if err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"client",
"*",
"S3Blobstore",
")",
"Get",
"(",
"src",
"string",
",",
"dest",
"io",
".",
"WriterAt",
")",
"error",
"{",
"downloader",
":=",
"s3manager",
".",
"NewDownloaderWithClient",
"(",
"client",
".",
"s3Client",
")",
"\n\n",
"_",
",",
"err",
":=",
"downloader",
".",
"Download",
"(",
"dest",
",",
"&",
"s3",
".",
"GetObjectInput",
"{",
"Bucket",
":",
"aws",
".",
"String",
"(",
"client",
".",
"s3cliConfig",
".",
"BucketName",
")",
",",
"Key",
":",
"client",
".",
"key",
"(",
"src",
")",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Get fetches a blob from an S3 compatible blobstore
// Destination will be overwritten if exists
|
[
"Get",
"fetches",
"a",
"blob",
"from",
"an",
"S3",
"compatible",
"blobstore",
"Destination",
"will",
"be",
"overwritten",
"if",
"exists"
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/client/client.go#L34-L47
|
16,140 |
cloudfoundry/bosh-s3cli
|
client/client.go
|
Put
|
func (client *S3Blobstore) Put(src io.ReadSeeker, dest string) error {
cfg := client.s3cliConfig
if cfg.CredentialsSource == config.NoneCredentialsSource {
return errorInvalidCredentialsSourceValue
}
uploader := s3manager.NewUploaderWithClient(client.s3Client, func(u *s3manager.Uploader) {
u.LeavePartsOnError = false
if !cfg.MultipartUpload {
// disable multipart uploads by way of large PartSize configuration
u.PartSize = oneTB
}
})
uploadInput := &s3manager.UploadInput{
Body: src,
Bucket: aws.String(cfg.BucketName),
Key: client.key(dest),
}
if cfg.ServerSideEncryption != "" {
uploadInput.ServerSideEncryption = aws.String(cfg.ServerSideEncryption)
}
if cfg.SSEKMSKeyID != "" {
uploadInput.SSEKMSKeyId = aws.String(cfg.SSEKMSKeyID)
}
retry := 0
maxRetries := 3
for {
putResult, err := uploader.Upload(uploadInput)
if err != nil {
if _, ok := err.(s3manager.MultiUploadFailure); ok {
if retry == maxRetries {
log.Println("Upload retry limit exceeded:", err.Error())
return fmt.Errorf("upload retry limit exceeded: %s", err.Error())
}
retry++
time.Sleep(time.Second * time.Duration(retry))
continue
}
log.Println("Upload failed:", err.Error())
return fmt.Errorf("upload failure: %s", err.Error())
}
log.Println("Successfully uploaded file to", putResult.Location)
return nil
}
}
|
go
|
func (client *S3Blobstore) Put(src io.ReadSeeker, dest string) error {
cfg := client.s3cliConfig
if cfg.CredentialsSource == config.NoneCredentialsSource {
return errorInvalidCredentialsSourceValue
}
uploader := s3manager.NewUploaderWithClient(client.s3Client, func(u *s3manager.Uploader) {
u.LeavePartsOnError = false
if !cfg.MultipartUpload {
// disable multipart uploads by way of large PartSize configuration
u.PartSize = oneTB
}
})
uploadInput := &s3manager.UploadInput{
Body: src,
Bucket: aws.String(cfg.BucketName),
Key: client.key(dest),
}
if cfg.ServerSideEncryption != "" {
uploadInput.ServerSideEncryption = aws.String(cfg.ServerSideEncryption)
}
if cfg.SSEKMSKeyID != "" {
uploadInput.SSEKMSKeyId = aws.String(cfg.SSEKMSKeyID)
}
retry := 0
maxRetries := 3
for {
putResult, err := uploader.Upload(uploadInput)
if err != nil {
if _, ok := err.(s3manager.MultiUploadFailure); ok {
if retry == maxRetries {
log.Println("Upload retry limit exceeded:", err.Error())
return fmt.Errorf("upload retry limit exceeded: %s", err.Error())
}
retry++
time.Sleep(time.Second * time.Duration(retry))
continue
}
log.Println("Upload failed:", err.Error())
return fmt.Errorf("upload failure: %s", err.Error())
}
log.Println("Successfully uploaded file to", putResult.Location)
return nil
}
}
|
[
"func",
"(",
"client",
"*",
"S3Blobstore",
")",
"Put",
"(",
"src",
"io",
".",
"ReadSeeker",
",",
"dest",
"string",
")",
"error",
"{",
"cfg",
":=",
"client",
".",
"s3cliConfig",
"\n",
"if",
"cfg",
".",
"CredentialsSource",
"==",
"config",
".",
"NoneCredentialsSource",
"{",
"return",
"errorInvalidCredentialsSourceValue",
"\n",
"}",
"\n\n",
"uploader",
":=",
"s3manager",
".",
"NewUploaderWithClient",
"(",
"client",
".",
"s3Client",
",",
"func",
"(",
"u",
"*",
"s3manager",
".",
"Uploader",
")",
"{",
"u",
".",
"LeavePartsOnError",
"=",
"false",
"\n\n",
"if",
"!",
"cfg",
".",
"MultipartUpload",
"{",
"// disable multipart uploads by way of large PartSize configuration",
"u",
".",
"PartSize",
"=",
"oneTB",
"\n",
"}",
"\n",
"}",
")",
"\n",
"uploadInput",
":=",
"&",
"s3manager",
".",
"UploadInput",
"{",
"Body",
":",
"src",
",",
"Bucket",
":",
"aws",
".",
"String",
"(",
"cfg",
".",
"BucketName",
")",
",",
"Key",
":",
"client",
".",
"key",
"(",
"dest",
")",
",",
"}",
"\n",
"if",
"cfg",
".",
"ServerSideEncryption",
"!=",
"\"",
"\"",
"{",
"uploadInput",
".",
"ServerSideEncryption",
"=",
"aws",
".",
"String",
"(",
"cfg",
".",
"ServerSideEncryption",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"SSEKMSKeyID",
"!=",
"\"",
"\"",
"{",
"uploadInput",
".",
"SSEKMSKeyId",
"=",
"aws",
".",
"String",
"(",
"cfg",
".",
"SSEKMSKeyID",
")",
"\n",
"}",
"\n\n",
"retry",
":=",
"0",
"\n",
"maxRetries",
":=",
"3",
"\n",
"for",
"{",
"putResult",
",",
"err",
":=",
"uploader",
".",
"Upload",
"(",
"uploadInput",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"s3manager",
".",
"MultiUploadFailure",
")",
";",
"ok",
"{",
"if",
"retry",
"==",
"maxRetries",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"retry",
"++",
"\n",
"time",
".",
"Sleep",
"(",
"time",
".",
"Second",
"*",
"time",
".",
"Duration",
"(",
"retry",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"putResult",
".",
"Location",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// Put uploads a blob to an S3 compatible blobstore
|
[
"Put",
"uploads",
"a",
"blob",
"to",
"an",
"S3",
"compatible",
"blobstore"
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/client/client.go#L50-L97
|
16,141 |
cloudfoundry/bosh-s3cli
|
client/client.go
|
Delete
|
func (client *S3Blobstore) Delete(dest string) error {
if client.s3cliConfig.CredentialsSource == config.NoneCredentialsSource {
return errorInvalidCredentialsSourceValue
}
deleteParams := &s3.DeleteObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(dest),
}
_, err := client.s3Client.DeleteObject(deleteParams)
if err == nil {
return nil
}
if reqErr, ok := err.(awserr.RequestFailure); ok {
if reqErr.StatusCode() == 404 {
return nil
}
}
return err
}
|
go
|
func (client *S3Blobstore) Delete(dest string) error {
if client.s3cliConfig.CredentialsSource == config.NoneCredentialsSource {
return errorInvalidCredentialsSourceValue
}
deleteParams := &s3.DeleteObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(dest),
}
_, err := client.s3Client.DeleteObject(deleteParams)
if err == nil {
return nil
}
if reqErr, ok := err.(awserr.RequestFailure); ok {
if reqErr.StatusCode() == 404 {
return nil
}
}
return err
}
|
[
"func",
"(",
"client",
"*",
"S3Blobstore",
")",
"Delete",
"(",
"dest",
"string",
")",
"error",
"{",
"if",
"client",
".",
"s3cliConfig",
".",
"CredentialsSource",
"==",
"config",
".",
"NoneCredentialsSource",
"{",
"return",
"errorInvalidCredentialsSourceValue",
"\n",
"}",
"\n\n",
"deleteParams",
":=",
"&",
"s3",
".",
"DeleteObjectInput",
"{",
"Bucket",
":",
"aws",
".",
"String",
"(",
"client",
".",
"s3cliConfig",
".",
"BucketName",
")",
",",
"Key",
":",
"client",
".",
"key",
"(",
"dest",
")",
",",
"}",
"\n\n",
"_",
",",
"err",
":=",
"client",
".",
"s3Client",
".",
"DeleteObject",
"(",
"deleteParams",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"reqErr",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"RequestFailure",
")",
";",
"ok",
"{",
"if",
"reqErr",
".",
"StatusCode",
"(",
")",
"==",
"404",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Delete removes a blob from an S3 compatible blobstore. If the object does
// not exist, Delete does not return an error.
|
[
"Delete",
"removes",
"a",
"blob",
"from",
"an",
"S3",
"compatible",
"blobstore",
".",
"If",
"the",
"object",
"does",
"not",
"exist",
"Delete",
"does",
"not",
"return",
"an",
"error",
"."
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/client/client.go#L101-L123
|
16,142 |
cloudfoundry/bosh-s3cli
|
client/client.go
|
Exists
|
func (client *S3Blobstore) Exists(dest string) (bool, error) {
existsParams := &s3.HeadObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(dest),
}
_, err := client.s3Client.HeadObject(existsParams)
if err == nil {
log.Printf("File '%s' exists in bucket '%s'\n", dest, client.s3cliConfig.BucketName)
return true, nil
}
if reqErr, ok := err.(awserr.RequestFailure); ok {
if reqErr.StatusCode() == 404 {
log.Printf("File '%s' does not exist in bucket '%s'\n", dest, client.s3cliConfig.BucketName)
return false, nil
}
}
return false, err
}
|
go
|
func (client *S3Blobstore) Exists(dest string) (bool, error) {
existsParams := &s3.HeadObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(dest),
}
_, err := client.s3Client.HeadObject(existsParams)
if err == nil {
log.Printf("File '%s' exists in bucket '%s'\n", dest, client.s3cliConfig.BucketName)
return true, nil
}
if reqErr, ok := err.(awserr.RequestFailure); ok {
if reqErr.StatusCode() == 404 {
log.Printf("File '%s' does not exist in bucket '%s'\n", dest, client.s3cliConfig.BucketName)
return false, nil
}
}
return false, err
}
|
[
"func",
"(",
"client",
"*",
"S3Blobstore",
")",
"Exists",
"(",
"dest",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"existsParams",
":=",
"&",
"s3",
".",
"HeadObjectInput",
"{",
"Bucket",
":",
"aws",
".",
"String",
"(",
"client",
".",
"s3cliConfig",
".",
"BucketName",
")",
",",
"Key",
":",
"client",
".",
"key",
"(",
"dest",
")",
",",
"}",
"\n\n",
"_",
",",
"err",
":=",
"client",
".",
"s3Client",
".",
"HeadObject",
"(",
"existsParams",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"dest",
",",
"client",
".",
"s3cliConfig",
".",
"BucketName",
")",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"reqErr",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"RequestFailure",
")",
";",
"ok",
"{",
"if",
"reqErr",
".",
"StatusCode",
"(",
")",
"==",
"404",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"dest",
",",
"client",
".",
"s3cliConfig",
".",
"BucketName",
")",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"err",
"\n",
"}"
] |
// Exists checks if blob exists in an S3 compatible blobstore
|
[
"Exists",
"checks",
"if",
"blob",
"exists",
"in",
"an",
"S3",
"compatible",
"blobstore"
] |
49a4c41327fdfa3c4993925cb6464707ecfabfab
|
https://github.com/cloudfoundry/bosh-s3cli/blob/49a4c41327fdfa3c4993925cb6464707ecfabfab/client/client.go#L126-L147
|
16,143 |
ForceCLI/force
|
lib/packagebuilder.go
|
PackageXml
|
func (pb PackageBuilder) PackageXml() []byte {
p := createPackage()
for _, metaType := range pb.Metadata {
p.Types = append(p.Types, metaType)
}
byteXml, _ := xml.MarshalIndent(p, "", " ")
byteXml = append([]byte(xml.Header), byteXml...)
//if err := ioutil.WriteFile("mypackage.xml", byteXml, 0644); err != nil {
//ErrorAndExit(err.Error())
//}
return byteXml
}
|
go
|
func (pb PackageBuilder) PackageXml() []byte {
p := createPackage()
for _, metaType := range pb.Metadata {
p.Types = append(p.Types, metaType)
}
byteXml, _ := xml.MarshalIndent(p, "", " ")
byteXml = append([]byte(xml.Header), byteXml...)
//if err := ioutil.WriteFile("mypackage.xml", byteXml, 0644); err != nil {
//ErrorAndExit(err.Error())
//}
return byteXml
}
|
[
"func",
"(",
"pb",
"PackageBuilder",
")",
"PackageXml",
"(",
")",
"[",
"]",
"byte",
"{",
"p",
":=",
"createPackage",
"(",
")",
"\n\n",
"for",
"_",
",",
"metaType",
":=",
"range",
"pb",
".",
"Metadata",
"{",
"p",
".",
"Types",
"=",
"append",
"(",
"p",
".",
"Types",
",",
"metaType",
")",
"\n",
"}",
"\n\n",
"byteXml",
",",
"_",
":=",
"xml",
".",
"MarshalIndent",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"byteXml",
"=",
"append",
"(",
"[",
"]",
"byte",
"(",
"xml",
".",
"Header",
")",
",",
"byteXml",
"...",
")",
"\n",
"//if err := ioutil.WriteFile(\"mypackage.xml\", byteXml, 0644); err != nil {",
"//ErrorAndExit(err.Error())",
"//}",
"return",
"byteXml",
"\n",
"}"
] |
// Build and return package.xml
|
[
"Build",
"and",
"return",
"package",
".",
"xml"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L149-L162
|
16,144 |
ForceCLI/force
|
lib/packagebuilder.go
|
ForceMetadataFiles
|
func (pb *PackageBuilder) ForceMetadataFiles() ForceMetadataFiles {
pb.Files["package.xml"] = pb.PackageXml()
return pb.Files
}
|
go
|
func (pb *PackageBuilder) ForceMetadataFiles() ForceMetadataFiles {
pb.Files["package.xml"] = pb.PackageXml()
return pb.Files
}
|
[
"func",
"(",
"pb",
"*",
"PackageBuilder",
")",
"ForceMetadataFiles",
"(",
")",
"ForceMetadataFiles",
"{",
"pb",
".",
"Files",
"[",
"\"",
"\"",
"]",
"=",
"pb",
".",
"PackageXml",
"(",
")",
"\n",
"return",
"pb",
".",
"Files",
"\n",
"}"
] |
// Returns the full ForceMetadataFiles container
|
[
"Returns",
"the",
"full",
"ForceMetadataFiles",
"container"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L165-L168
|
16,145 |
ForceCLI/force
|
lib/packagebuilder.go
|
MetaPathToSourcePath
|
func MetaPathToSourcePath(mpath string) (spath string) {
spath = strings.TrimSuffix(mpath, "-meta.xml")
if spath == mpath {
return
}
_, err := os.Stat(spath)
if err != nil {
spath = mpath
}
return
}
|
go
|
func MetaPathToSourcePath(mpath string) (spath string) {
spath = strings.TrimSuffix(mpath, "-meta.xml")
if spath == mpath {
return
}
_, err := os.Stat(spath)
if err != nil {
spath = mpath
}
return
}
|
[
"func",
"MetaPathToSourcePath",
"(",
"mpath",
"string",
")",
"(",
"spath",
"string",
")",
"{",
"spath",
"=",
"strings",
".",
"TrimSuffix",
"(",
"mpath",
",",
"\"",
"\"",
")",
"\n",
"if",
"spath",
"==",
"mpath",
"{",
"return",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"spath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"spath",
"=",
"mpath",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Returns the source file path for a given metadata file path.
|
[
"Returns",
"the",
"source",
"file",
"path",
"for",
"a",
"given",
"metadata",
"file",
"path",
"."
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L171-L182
|
16,146 |
ForceCLI/force
|
lib/packagebuilder.go
|
AddFile
|
func (pb *PackageBuilder) AddFile(fpath string) (fname string, err error) {
fpath, err = filepath.Abs(fpath)
if err != nil {
return
}
_, err = os.Stat(fpath)
if err != nil {
return
}
isDestructiveChanges, err := regexp.MatchString("destructiveChanges(Pre|Post)?"+regexp.QuoteMeta(".")+"xml", fpath)
if err != nil {
return
}
fpath = MetaPathToSourcePath(fpath)
metaName, fname := getMetaTypeFromPath(fpath)
if !isDestructiveChanges && !strings.HasSuffix(fpath, "-meta.xml") {
pb.AddMetaToPackage(metaName, fname)
}
// If it's a push, we want to actually add the files
if pb.IsPush {
if isDestructiveChanges {
err = pb.addDestructiveChanges(fpath)
} else {
err = pb.addFileToWorkingDir(metaName, fpath)
}
}
return
}
|
go
|
func (pb *PackageBuilder) AddFile(fpath string) (fname string, err error) {
fpath, err = filepath.Abs(fpath)
if err != nil {
return
}
_, err = os.Stat(fpath)
if err != nil {
return
}
isDestructiveChanges, err := regexp.MatchString("destructiveChanges(Pre|Post)?"+regexp.QuoteMeta(".")+"xml", fpath)
if err != nil {
return
}
fpath = MetaPathToSourcePath(fpath)
metaName, fname := getMetaTypeFromPath(fpath)
if !isDestructiveChanges && !strings.HasSuffix(fpath, "-meta.xml") {
pb.AddMetaToPackage(metaName, fname)
}
// If it's a push, we want to actually add the files
if pb.IsPush {
if isDestructiveChanges {
err = pb.addDestructiveChanges(fpath)
} else {
err = pb.addFileToWorkingDir(metaName, fpath)
}
}
return
}
|
[
"func",
"(",
"pb",
"*",
"PackageBuilder",
")",
"AddFile",
"(",
"fpath",
"string",
")",
"(",
"fname",
"string",
",",
"err",
"error",
")",
"{",
"fpath",
",",
"err",
"=",
"filepath",
".",
"Abs",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"isDestructiveChanges",
",",
"err",
":=",
"regexp",
".",
"MatchString",
"(",
"\"",
"\"",
"+",
"regexp",
".",
"QuoteMeta",
"(",
"\"",
"\"",
")",
"+",
"\"",
"\"",
",",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"fpath",
"=",
"MetaPathToSourcePath",
"(",
"fpath",
")",
"\n",
"metaName",
",",
"fname",
":=",
"getMetaTypeFromPath",
"(",
"fpath",
")",
"\n",
"if",
"!",
"isDestructiveChanges",
"&&",
"!",
"strings",
".",
"HasSuffix",
"(",
"fpath",
",",
"\"",
"\"",
")",
"{",
"pb",
".",
"AddMetaToPackage",
"(",
"metaName",
",",
"fname",
")",
"\n",
"}",
"\n\n",
"// If it's a push, we want to actually add the files",
"if",
"pb",
".",
"IsPush",
"{",
"if",
"isDestructiveChanges",
"{",
"err",
"=",
"pb",
".",
"addDestructiveChanges",
"(",
"fpath",
")",
"\n",
"}",
"else",
"{",
"err",
"=",
"pb",
".",
"addFileToWorkingDir",
"(",
"metaName",
",",
"fpath",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Add a file to the builder
|
[
"Add",
"a",
"file",
"to",
"the",
"builder"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L185-L216
|
16,147 |
ForceCLI/force
|
lib/packagebuilder.go
|
AddDirectory
|
func (pb *PackageBuilder) AddDirectory(fpath string) (namePaths map[string]string, badPaths []string, err error) {
namePaths = make(map[string]string)
files, err := ioutil.ReadDir(fpath)
if err != nil {
badPaths = append(badPaths, fpath)
return
}
for _, f := range files {
dirOrFilePath := fpath + "/" + f.Name()
if f.IsDir() {
dirNamePaths, dirBadPath, err := pb.AddDirectory(dirOrFilePath)
if err != nil {
badPaths = append(badPaths, dirBadPath...)
} else {
for dirContentName, dirContentPath := range dirNamePaths {
namePaths[dirContentName] = dirContentPath
}
}
}
name, err := pb.AddFile(dirOrFilePath)
if (err != nil) || (name == "") {
badPaths = append(badPaths, dirOrFilePath)
} else {
namePaths[name] = dirOrFilePath
}
}
return
}
|
go
|
func (pb *PackageBuilder) AddDirectory(fpath string) (namePaths map[string]string, badPaths []string, err error) {
namePaths = make(map[string]string)
files, err := ioutil.ReadDir(fpath)
if err != nil {
badPaths = append(badPaths, fpath)
return
}
for _, f := range files {
dirOrFilePath := fpath + "/" + f.Name()
if f.IsDir() {
dirNamePaths, dirBadPath, err := pb.AddDirectory(dirOrFilePath)
if err != nil {
badPaths = append(badPaths, dirBadPath...)
} else {
for dirContentName, dirContentPath := range dirNamePaths {
namePaths[dirContentName] = dirContentPath
}
}
}
name, err := pb.AddFile(dirOrFilePath)
if (err != nil) || (name == "") {
badPaths = append(badPaths, dirOrFilePath)
} else {
namePaths[name] = dirOrFilePath
}
}
return
}
|
[
"func",
"(",
"pb",
"*",
"PackageBuilder",
")",
"AddDirectory",
"(",
"fpath",
"string",
")",
"(",
"namePaths",
"map",
"[",
"string",
"]",
"string",
",",
"badPaths",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"namePaths",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n\n",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"badPaths",
"=",
"append",
"(",
"badPaths",
",",
"fpath",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"f",
":=",
"range",
"files",
"{",
"dirOrFilePath",
":=",
"fpath",
"+",
"\"",
"\"",
"+",
"f",
".",
"Name",
"(",
")",
"\n",
"if",
"f",
".",
"IsDir",
"(",
")",
"{",
"dirNamePaths",
",",
"dirBadPath",
",",
"err",
":=",
"pb",
".",
"AddDirectory",
"(",
"dirOrFilePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"badPaths",
"=",
"append",
"(",
"badPaths",
",",
"dirBadPath",
"...",
")",
"\n",
"}",
"else",
"{",
"for",
"dirContentName",
",",
"dirContentPath",
":=",
"range",
"dirNamePaths",
"{",
"namePaths",
"[",
"dirContentName",
"]",
"=",
"dirContentPath",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"name",
",",
"err",
":=",
"pb",
".",
"AddFile",
"(",
"dirOrFilePath",
")",
"\n\n",
"if",
"(",
"err",
"!=",
"nil",
")",
"||",
"(",
"name",
"==",
"\"",
"\"",
")",
"{",
"badPaths",
"=",
"append",
"(",
"badPaths",
",",
"dirOrFilePath",
")",
"\n",
"}",
"else",
"{",
"namePaths",
"[",
"name",
"]",
"=",
"dirOrFilePath",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
//AddDirectory Recursively add files contained in provided directory
|
[
"AddDirectory",
"Recursively",
"add",
"files",
"contained",
"in",
"provided",
"directory"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L219-L250
|
16,148 |
ForceCLI/force
|
lib/packagebuilder.go
|
addFileToWorkingDir
|
func (pb *PackageBuilder) addFileToWorkingDir(metaName string, fpath string) (err error) {
// Get relative dir from source
srcDir := filepath.Dir(filepath.Dir(fpath))
for _, mp := range metapaths {
if metaName == mp.name && mp.hasFolder {
srcDir = filepath.Dir(srcDir)
}
}
frel, _ := filepath.Rel(srcDir, fpath)
// Try to find meta file
hasMeta := true
fmeta := fpath + "-meta.xml"
fmetarel := ""
if _, err = os.Stat(fmeta); err != nil {
if os.IsNotExist(err) {
hasMeta = false
} else {
// Has error
return
}
} else {
// Should be present since we worked back to srcDir
fmetarel, _ = filepath.Rel(srcDir, fmeta)
}
fdata, err := ioutil.ReadFile(fpath)
if err != nil {
return
}
pb.Files[frel] = fdata
if hasMeta {
fdata, err = ioutil.ReadFile(fmeta)
pb.Files[fmetarel] = fdata
return
}
return
}
|
go
|
func (pb *PackageBuilder) addFileToWorkingDir(metaName string, fpath string) (err error) {
// Get relative dir from source
srcDir := filepath.Dir(filepath.Dir(fpath))
for _, mp := range metapaths {
if metaName == mp.name && mp.hasFolder {
srcDir = filepath.Dir(srcDir)
}
}
frel, _ := filepath.Rel(srcDir, fpath)
// Try to find meta file
hasMeta := true
fmeta := fpath + "-meta.xml"
fmetarel := ""
if _, err = os.Stat(fmeta); err != nil {
if os.IsNotExist(err) {
hasMeta = false
} else {
// Has error
return
}
} else {
// Should be present since we worked back to srcDir
fmetarel, _ = filepath.Rel(srcDir, fmeta)
}
fdata, err := ioutil.ReadFile(fpath)
if err != nil {
return
}
pb.Files[frel] = fdata
if hasMeta {
fdata, err = ioutil.ReadFile(fmeta)
pb.Files[fmetarel] = fdata
return
}
return
}
|
[
"func",
"(",
"pb",
"*",
"PackageBuilder",
")",
"addFileToWorkingDir",
"(",
"metaName",
"string",
",",
"fpath",
"string",
")",
"(",
"err",
"error",
")",
"{",
"// Get relative dir from source",
"srcDir",
":=",
"filepath",
".",
"Dir",
"(",
"filepath",
".",
"Dir",
"(",
"fpath",
")",
")",
"\n",
"for",
"_",
",",
"mp",
":=",
"range",
"metapaths",
"{",
"if",
"metaName",
"==",
"mp",
".",
"name",
"&&",
"mp",
".",
"hasFolder",
"{",
"srcDir",
"=",
"filepath",
".",
"Dir",
"(",
"srcDir",
")",
"\n",
"}",
"\n",
"}",
"\n",
"frel",
",",
"_",
":=",
"filepath",
".",
"Rel",
"(",
"srcDir",
",",
"fpath",
")",
"\n\n",
"// Try to find meta file",
"hasMeta",
":=",
"true",
"\n",
"fmeta",
":=",
"fpath",
"+",
"\"",
"\"",
"\n",
"fmetarel",
":=",
"\"",
"\"",
"\n",
"if",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"fmeta",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"hasMeta",
"=",
"false",
"\n",
"}",
"else",
"{",
"// Has error",
"return",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Should be present since we worked back to srcDir",
"fmetarel",
",",
"_",
"=",
"filepath",
".",
"Rel",
"(",
"srcDir",
",",
"fmeta",
")",
"\n",
"}",
"\n\n",
"fdata",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"pb",
".",
"Files",
"[",
"frel",
"]",
"=",
"fdata",
"\n",
"if",
"hasMeta",
"{",
"fdata",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"fmeta",
")",
"\n",
"pb",
".",
"Files",
"[",
"fmetarel",
"]",
"=",
"fdata",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Adds the file to a temp directory for deploy
|
[
"Adds",
"the",
"file",
"to",
"a",
"temp",
"directory",
"for",
"deploy"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L253-L292
|
16,149 |
ForceCLI/force
|
lib/packagebuilder.go
|
AddMetaToPackage
|
func (pb *PackageBuilder) AddMetaToPackage(metaName string, name string) {
mt := pb.Metadata[metaName]
if mt.Name == "" {
mt.Name = metaName
}
if !pb.contains(mt.Members, name) {
mt.Members = append(mt.Members, name)
pb.Metadata[metaName] = mt
}
}
|
go
|
func (pb *PackageBuilder) AddMetaToPackage(metaName string, name string) {
mt := pb.Metadata[metaName]
if mt.Name == "" {
mt.Name = metaName
}
if !pb.contains(mt.Members, name) {
mt.Members = append(mt.Members, name)
pb.Metadata[metaName] = mt
}
}
|
[
"func",
"(",
"pb",
"*",
"PackageBuilder",
")",
"AddMetaToPackage",
"(",
"metaName",
"string",
",",
"name",
"string",
")",
"{",
"mt",
":=",
"pb",
".",
"Metadata",
"[",
"metaName",
"]",
"\n",
"if",
"mt",
".",
"Name",
"==",
"\"",
"\"",
"{",
"mt",
".",
"Name",
"=",
"metaName",
"\n",
"}",
"\n\n",
"if",
"!",
"pb",
".",
"contains",
"(",
"mt",
".",
"Members",
",",
"name",
")",
"{",
"mt",
".",
"Members",
"=",
"append",
"(",
"mt",
".",
"Members",
",",
"name",
")",
"\n",
"pb",
".",
"Metadata",
"[",
"metaName",
"]",
"=",
"mt",
"\n",
"}",
"\n",
"}"
] |
// Adds a metadata name to the pending package
|
[
"Adds",
"a",
"metadata",
"name",
"to",
"the",
"pending",
"package"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L316-L326
|
16,150 |
ForceCLI/force
|
lib/packagebuilder.go
|
getMetaTypeFromPath
|
func getMetaTypeFromPath(fpath string) (metaName string, name string) {
fpath, err := filepath.Abs(fpath)
if err != nil {
ErrorAndExit("Cound not find " + fpath)
}
if _, err := os.Stat(fpath); err != nil {
ErrorAndExit("Cound not open " + fpath)
}
// Get the metadata type and name for the file
metaName, fileName := getMetaForPath(fpath)
name = strings.TrimSuffix(fileName, filepath.Ext(fileName))
//name = strings.TrimSuffix(name, filepath.Ext(name))
return
}
|
go
|
func getMetaTypeFromPath(fpath string) (metaName string, name string) {
fpath, err := filepath.Abs(fpath)
if err != nil {
ErrorAndExit("Cound not find " + fpath)
}
if _, err := os.Stat(fpath); err != nil {
ErrorAndExit("Cound not open " + fpath)
}
// Get the metadata type and name for the file
metaName, fileName := getMetaForPath(fpath)
name = strings.TrimSuffix(fileName, filepath.Ext(fileName))
//name = strings.TrimSuffix(name, filepath.Ext(name))
return
}
|
[
"func",
"getMetaTypeFromPath",
"(",
"fpath",
"string",
")",
"(",
"metaName",
"string",
",",
"name",
"string",
")",
"{",
"fpath",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ErrorAndExit",
"(",
"\"",
"\"",
"+",
"fpath",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"fpath",
")",
";",
"err",
"!=",
"nil",
"{",
"ErrorAndExit",
"(",
"\"",
"\"",
"+",
"fpath",
")",
"\n",
"}",
"\n\n",
"// Get the metadata type and name for the file",
"metaName",
",",
"fileName",
":=",
"getMetaForPath",
"(",
"fpath",
")",
"\n",
"name",
"=",
"strings",
".",
"TrimSuffix",
"(",
"fileName",
",",
"filepath",
".",
"Ext",
"(",
"fileName",
")",
")",
"\n",
"//name = strings.TrimSuffix(name, filepath.Ext(name))",
"return",
"\n",
"}"
] |
// Gets metadata type name and target name from a file path
|
[
"Gets",
"metadata",
"type",
"name",
"and",
"target",
"name",
"from",
"a",
"file",
"path"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L329-L343
|
16,151 |
ForceCLI/force
|
lib/packagebuilder.go
|
getMetaForPath
|
func getMetaForPath(path string) (metaName string, objectName string) {
parentDir := filepath.Dir(path)
parentName := filepath.Base(parentDir)
grandparentName := filepath.Base(filepath.Dir(parentDir))
fileName := filepath.Base(path)
for _, mp := range metapaths {
if mp.hasFolder && grandparentName == mp.path {
metaName = mp.name
if mp.onlyFolder {
objectName = parentName
} else {
objectName = parentName + "/" + fileName
}
return
}
if mp.path == parentName {
metaName = mp.name
objectName = fileName
return
}
}
// Unknown, so use path
metaName = parentName
objectName = fileName
return
}
|
go
|
func getMetaForPath(path string) (metaName string, objectName string) {
parentDir := filepath.Dir(path)
parentName := filepath.Base(parentDir)
grandparentName := filepath.Base(filepath.Dir(parentDir))
fileName := filepath.Base(path)
for _, mp := range metapaths {
if mp.hasFolder && grandparentName == mp.path {
metaName = mp.name
if mp.onlyFolder {
objectName = parentName
} else {
objectName = parentName + "/" + fileName
}
return
}
if mp.path == parentName {
metaName = mp.name
objectName = fileName
return
}
}
// Unknown, so use path
metaName = parentName
objectName = fileName
return
}
|
[
"func",
"getMetaForPath",
"(",
"path",
"string",
")",
"(",
"metaName",
"string",
",",
"objectName",
"string",
")",
"{",
"parentDir",
":=",
"filepath",
".",
"Dir",
"(",
"path",
")",
"\n",
"parentName",
":=",
"filepath",
".",
"Base",
"(",
"parentDir",
")",
"\n",
"grandparentName",
":=",
"filepath",
".",
"Base",
"(",
"filepath",
".",
"Dir",
"(",
"parentDir",
")",
")",
"\n",
"fileName",
":=",
"filepath",
".",
"Base",
"(",
"path",
")",
"\n\n",
"for",
"_",
",",
"mp",
":=",
"range",
"metapaths",
"{",
"if",
"mp",
".",
"hasFolder",
"&&",
"grandparentName",
"==",
"mp",
".",
"path",
"{",
"metaName",
"=",
"mp",
".",
"name",
"\n",
"if",
"mp",
".",
"onlyFolder",
"{",
"objectName",
"=",
"parentName",
"\n",
"}",
"else",
"{",
"objectName",
"=",
"parentName",
"+",
"\"",
"\"",
"+",
"fileName",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"mp",
".",
"path",
"==",
"parentName",
"{",
"metaName",
"=",
"mp",
".",
"name",
"\n",
"objectName",
"=",
"fileName",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Unknown, so use path",
"metaName",
"=",
"parentName",
"\n",
"objectName",
"=",
"fileName",
"\n",
"return",
"\n",
"}"
] |
// Gets meta type and name based on a path
|
[
"Gets",
"meta",
"type",
"and",
"name",
"based",
"on",
"a",
"path"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/packagebuilder.go#L370-L397
|
16,152 |
ForceCLI/force
|
command/push.go
|
getMDTypeFromXml
|
func getMDTypeFromXml(path string) (mdtype string, err error) {
xmlFile, err := ioutil.ReadFile(path)
mdtype = getFirstXmlElement(xmlFile)
return
}
|
go
|
func getMDTypeFromXml(path string) (mdtype string, err error) {
xmlFile, err := ioutil.ReadFile(path)
mdtype = getFirstXmlElement(xmlFile)
return
}
|
[
"func",
"getMDTypeFromXml",
"(",
"path",
"string",
")",
"(",
"mdtype",
"string",
",",
"err",
"error",
")",
"{",
"xmlFile",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"path",
")",
"\n",
"mdtype",
"=",
"getFirstXmlElement",
"(",
"xmlFile",
")",
"\n",
"return",
"\n",
"}"
] |
// Return the name of the first element of an XML file. We need this
// because the metadata xml uses the metadata type as the first element
// in the metadata xml definition. Could be a better way of doing this.
|
[
"Return",
"the",
"name",
"of",
"the",
"first",
"element",
"of",
"an",
"XML",
"file",
".",
"We",
"need",
"this",
"because",
"the",
"metadata",
"xml",
"uses",
"the",
"metadata",
"type",
"as",
"the",
"first",
"element",
"in",
"the",
"metadata",
"xml",
"definition",
".",
"Could",
"be",
"a",
"better",
"way",
"of",
"doing",
"this",
"."
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/command/push.go#L216-L220
|
16,153 |
ForceCLI/force
|
command/push.go
|
getFirstXmlElement
|
func getFirstXmlElement(xmlFile []byte) (firstElement string) {
decoder := xml.NewDecoder(strings.NewReader(string(xmlFile)))
for {
token, _ := decoder.Token()
if token == nil {
break
}
switch startElement := token.(type) {
case xml.StartElement:
firstElement = startElement.Name.Local
return
}
}
return
}
|
go
|
func getFirstXmlElement(xmlFile []byte) (firstElement string) {
decoder := xml.NewDecoder(strings.NewReader(string(xmlFile)))
for {
token, _ := decoder.Token()
if token == nil {
break
}
switch startElement := token.(type) {
case xml.StartElement:
firstElement = startElement.Name.Local
return
}
}
return
}
|
[
"func",
"getFirstXmlElement",
"(",
"xmlFile",
"[",
"]",
"byte",
")",
"(",
"firstElement",
"string",
")",
"{",
"decoder",
":=",
"xml",
".",
"NewDecoder",
"(",
"strings",
".",
"NewReader",
"(",
"string",
"(",
"xmlFile",
")",
")",
")",
"\n",
"for",
"{",
"token",
",",
"_",
":=",
"decoder",
".",
"Token",
"(",
")",
"\n",
"if",
"token",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"switch",
"startElement",
":=",
"token",
".",
"(",
"type",
")",
"{",
"case",
"xml",
".",
"StartElement",
":",
"firstElement",
"=",
"startElement",
".",
"Name",
".",
"Local",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Helper function to read the first element of an XML file.
|
[
"Helper",
"function",
"to",
"read",
"the",
"first",
"element",
"of",
"an",
"XML",
"file",
"."
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/command/push.go#L223-L237
|
16,154 |
ForceCLI/force
|
command/push.go
|
findMetadataTypeFolder
|
func findMetadataTypeFolder(mdtype string, root string) (folder string) {
filepath.Walk(root, func(path string, f os.FileInfo, err error) error {
firstEl, _ := getMDTypeFromXml(path)
if firstEl == mdtype {
// This is sufficient for MD that does not have sub folders (classes, pages, etc)
// It is NOT sufficient for aura bundles
if mdtype == "AuraDefinitionBundle" {
// Need the parent of this folder to get all aura bundles in the directory
folder = filepath.Dir(filepath.Dir(path))
} else {
folder = filepath.Dir(path)
}
return errors.New("walk canceled")
}
return nil
})
return
}
|
go
|
func findMetadataTypeFolder(mdtype string, root string) (folder string) {
filepath.Walk(root, func(path string, f os.FileInfo, err error) error {
firstEl, _ := getMDTypeFromXml(path)
if firstEl == mdtype {
// This is sufficient for MD that does not have sub folders (classes, pages, etc)
// It is NOT sufficient for aura bundles
if mdtype == "AuraDefinitionBundle" {
// Need the parent of this folder to get all aura bundles in the directory
folder = filepath.Dir(filepath.Dir(path))
} else {
folder = filepath.Dir(path)
}
return errors.New("walk canceled")
}
return nil
})
return
}
|
[
"func",
"findMetadataTypeFolder",
"(",
"mdtype",
"string",
",",
"root",
"string",
")",
"(",
"folder",
"string",
")",
"{",
"filepath",
".",
"Walk",
"(",
"root",
",",
"func",
"(",
"path",
"string",
",",
"f",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"firstEl",
",",
"_",
":=",
"getMDTypeFromXml",
"(",
"path",
")",
"\n",
"if",
"firstEl",
"==",
"mdtype",
"{",
"// This is sufficient for MD that does not have sub folders (classes, pages, etc)",
"// It is NOT sufficient for aura bundles",
"if",
"mdtype",
"==",
"\"",
"\"",
"{",
"// Need the parent of this folder to get all aura bundles in the directory",
"folder",
"=",
"filepath",
".",
"Dir",
"(",
"filepath",
".",
"Dir",
"(",
"path",
")",
")",
"\n",
"}",
"else",
"{",
"folder",
"=",
"filepath",
".",
"Dir",
"(",
"path",
")",
"\n",
"}",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"\n",
"}"
] |
// Look for xml files. When one is found, check the first element of the
// XML. It should be the metadata type as expected by the platform. See
// if it matches the type passed in on mdtype, and if so, return the folder
// that contains the xml file, then bail out. If no file is found for the
// passed in type, then folder is empty.
|
[
"Look",
"for",
"xml",
"files",
".",
"When",
"one",
"is",
"found",
"check",
"the",
"first",
"element",
"of",
"the",
"XML",
".",
"It",
"should",
"be",
"the",
"metadata",
"type",
"as",
"expected",
"by",
"the",
"platform",
".",
"See",
"if",
"it",
"matches",
"the",
"type",
"passed",
"in",
"on",
"mdtype",
"and",
"if",
"so",
"return",
"the",
"folder",
"that",
"contains",
"the",
"xml",
"file",
"then",
"bail",
"out",
".",
"If",
"no",
"file",
"is",
"found",
"for",
"the",
"passed",
"in",
"type",
"then",
"folder",
"is",
"empty",
"."
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/command/push.go#L244-L262
|
16,155 |
ForceCLI/force
|
command/push.go
|
zipResource
|
func zipResource(path string, topLevelFolder string) {
zipfile := new(bytes.Buffer)
zipper := zip.NewWriter(zipfile)
startPath := path + "/"
filepath.Walk(path, func(path string, f os.FileInfo, err error) error {
if strings.ToLower(filepath.Base(path)) != ".ds_store" {
// Can skip dirs since the dirs will be created when the files are added
if !f.IsDir() {
file, err := ioutil.ReadFile(path)
if err != nil {
return err
}
fl, err := zipper.Create(filepath.Join(topLevelFolder, strings.Replace(path, startPath, "", -1)))
if err != nil {
ErrorAndExit(err.Error())
}
_, err = fl.Write([]byte(file))
if err != nil {
ErrorAndExit(err.Error())
}
}
}
return nil
})
zipper.Close()
zipdata := zipfile.Bytes()
ioutil.WriteFile(path+".resource", zipdata, 0644)
return
}
|
go
|
func zipResource(path string, topLevelFolder string) {
zipfile := new(bytes.Buffer)
zipper := zip.NewWriter(zipfile)
startPath := path + "/"
filepath.Walk(path, func(path string, f os.FileInfo, err error) error {
if strings.ToLower(filepath.Base(path)) != ".ds_store" {
// Can skip dirs since the dirs will be created when the files are added
if !f.IsDir() {
file, err := ioutil.ReadFile(path)
if err != nil {
return err
}
fl, err := zipper.Create(filepath.Join(topLevelFolder, strings.Replace(path, startPath, "", -1)))
if err != nil {
ErrorAndExit(err.Error())
}
_, err = fl.Write([]byte(file))
if err != nil {
ErrorAndExit(err.Error())
}
}
}
return nil
})
zipper.Close()
zipdata := zipfile.Bytes()
ioutil.WriteFile(path+".resource", zipdata, 0644)
return
}
|
[
"func",
"zipResource",
"(",
"path",
"string",
",",
"topLevelFolder",
"string",
")",
"{",
"zipfile",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"zipper",
":=",
"zip",
".",
"NewWriter",
"(",
"zipfile",
")",
"\n",
"startPath",
":=",
"path",
"+",
"\"",
"\"",
"\n",
"filepath",
".",
"Walk",
"(",
"path",
",",
"func",
"(",
"path",
"string",
",",
"f",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"if",
"strings",
".",
"ToLower",
"(",
"filepath",
".",
"Base",
"(",
"path",
")",
")",
"!=",
"\"",
"\"",
"{",
"// Can skip dirs since the dirs will be created when the files are added",
"if",
"!",
"f",
".",
"IsDir",
"(",
")",
"{",
"file",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"fl",
",",
"err",
":=",
"zipper",
".",
"Create",
"(",
"filepath",
".",
"Join",
"(",
"topLevelFolder",
",",
"strings",
".",
"Replace",
"(",
"path",
",",
"startPath",
",",
"\"",
"\"",
",",
"-",
"1",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ErrorAndExit",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"fl",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"file",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ErrorAndExit",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n\n",
"zipper",
".",
"Close",
"(",
")",
"\n",
"zipdata",
":=",
"zipfile",
".",
"Bytes",
"(",
")",
"\n",
"ioutil",
".",
"WriteFile",
"(",
"path",
"+",
"\"",
"\"",
",",
"zipdata",
",",
"0644",
")",
"\n",
"return",
"\n",
"}"
] |
// Just zip up what ever is in the path
|
[
"Just",
"zip",
"up",
"what",
"ever",
"is",
"in",
"the",
"path"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/command/push.go#L390-L419
|
16,156 |
ForceCLI/force
|
lib/auth.go
|
ForceSaveLogin
|
func ForceSaveLogin(creds ForceSession, output *os.File) (sessionName string, err error) {
userinfo, err := getUserInfo(creds)
if err != nil {
return
}
creds.UserInfo = &userinfo
creds.SessionOptions.ApiVersion = ApiVersionNumber()
fmt.Fprintf(output, "Logged in as '%s' (API %s)\n", creds.UserInfo.UserName, ApiVersionNumber())
if err = SaveLogin(creds); err != nil {
return
}
sessionName = creds.SessionName()
err = SetActiveLogin(sessionName)
return
}
|
go
|
func ForceSaveLogin(creds ForceSession, output *os.File) (sessionName string, err error) {
userinfo, err := getUserInfo(creds)
if err != nil {
return
}
creds.UserInfo = &userinfo
creds.SessionOptions.ApiVersion = ApiVersionNumber()
fmt.Fprintf(output, "Logged in as '%s' (API %s)\n", creds.UserInfo.UserName, ApiVersionNumber())
if err = SaveLogin(creds); err != nil {
return
}
sessionName = creds.SessionName()
err = SetActiveLogin(sessionName)
return
}
|
[
"func",
"ForceSaveLogin",
"(",
"creds",
"ForceSession",
",",
"output",
"*",
"os",
".",
"File",
")",
"(",
"sessionName",
"string",
",",
"err",
"error",
")",
"{",
"userinfo",
",",
"err",
":=",
"getUserInfo",
"(",
"creds",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"creds",
".",
"UserInfo",
"=",
"&",
"userinfo",
"\n",
"creds",
".",
"SessionOptions",
".",
"ApiVersion",
"=",
"ApiVersionNumber",
"(",
")",
"\n\n",
"fmt",
".",
"Fprintf",
"(",
"output",
",",
"\"",
"\\n",
"\"",
",",
"creds",
".",
"UserInfo",
".",
"UserName",
",",
"ApiVersionNumber",
"(",
")",
")",
"\n\n",
"if",
"err",
"=",
"SaveLogin",
"(",
"creds",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"sessionName",
"=",
"creds",
".",
"SessionName",
"(",
")",
"\n",
"err",
"=",
"SetActiveLogin",
"(",
"sessionName",
")",
"\n",
"return",
"\n",
"}"
] |
// Save the credentials as the active session with the UserInfo and with the
// default current API version.
|
[
"Save",
"the",
"credentials",
"as",
"the",
"active",
"session",
"with",
"the",
"UserInfo",
"and",
"with",
"the",
"default",
"current",
"API",
"version",
"."
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/auth.go#L57-L73
|
16,157 |
ForceCLI/force
|
lib/auth.go
|
upgradeCredentials
|
func upgradeCredentials(creds *ForceSession) (err error) {
if creds.SessionOptions != nil && creds.UserInfo != nil {
return
}
if creds.SessionOptions == nil {
creds.SessionOptions = &SessionOptions{
ApiVersion: ApiVersionNumber(),
}
if creds.RefreshToken != "" {
creds.SessionOptions.RefreshMethod = RefreshOauth
}
}
if creds.UserInfo == nil || creds.UserInfo.UserName == "" {
force := NewForce(creds)
err = force.RefreshSession()
if err != nil {
return
}
var userinfo UserInfo
userinfo, err = getUserInfo(*creds)
if err != nil {
return
}
creds.UserInfo = &userinfo
_, err = ForceSaveLogin(*creds, os.Stderr)
}
return
}
|
go
|
func upgradeCredentials(creds *ForceSession) (err error) {
if creds.SessionOptions != nil && creds.UserInfo != nil {
return
}
if creds.SessionOptions == nil {
creds.SessionOptions = &SessionOptions{
ApiVersion: ApiVersionNumber(),
}
if creds.RefreshToken != "" {
creds.SessionOptions.RefreshMethod = RefreshOauth
}
}
if creds.UserInfo == nil || creds.UserInfo.UserName == "" {
force := NewForce(creds)
err = force.RefreshSession()
if err != nil {
return
}
var userinfo UserInfo
userinfo, err = getUserInfo(*creds)
if err != nil {
return
}
creds.UserInfo = &userinfo
_, err = ForceSaveLogin(*creds, os.Stderr)
}
return
}
|
[
"func",
"upgradeCredentials",
"(",
"creds",
"*",
"ForceSession",
")",
"(",
"err",
"error",
")",
"{",
"if",
"creds",
".",
"SessionOptions",
"!=",
"nil",
"&&",
"creds",
".",
"UserInfo",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"creds",
".",
"SessionOptions",
"==",
"nil",
"{",
"creds",
".",
"SessionOptions",
"=",
"&",
"SessionOptions",
"{",
"ApiVersion",
":",
"ApiVersionNumber",
"(",
")",
",",
"}",
"\n",
"if",
"creds",
".",
"RefreshToken",
"!=",
"\"",
"\"",
"{",
"creds",
".",
"SessionOptions",
".",
"RefreshMethod",
"=",
"RefreshOauth",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"creds",
".",
"UserInfo",
"==",
"nil",
"||",
"creds",
".",
"UserInfo",
".",
"UserName",
"==",
"\"",
"\"",
"{",
"force",
":=",
"NewForce",
"(",
"creds",
")",
"\n",
"err",
"=",
"force",
".",
"RefreshSession",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"var",
"userinfo",
"UserInfo",
"\n",
"userinfo",
",",
"err",
"=",
"getUserInfo",
"(",
"*",
"creds",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"creds",
".",
"UserInfo",
"=",
"&",
"userinfo",
"\n",
"_",
",",
"err",
"=",
"ForceSaveLogin",
"(",
"*",
"creds",
",",
"os",
".",
"Stderr",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Add UserInfo and SessionOptions to old ForceSession
|
[
"Add",
"UserInfo",
"and",
"SessionOptions",
"to",
"old",
"ForceSession"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/auth.go#L139-L166
|
16,158 |
ForceCLI/force
|
lib/metadata.go
|
getAttributes
|
func getAttributes(m interface{}) map[string]reflect.StructField {
typ := reflect.TypeOf(m)
// if a pointer to a struct is passed, get the type of the dereferenced object
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
// create an attribute data structure as a map of types keyed by a string.
attrs := make(map[string]reflect.StructField)
// Only structs are supported so return an empty result if the passed object
// isn't a struct
if typ.Kind() != reflect.Struct {
fmt.Printf("%v type can't have attributes inspected\n", typ.Kind())
return attrs
}
// loop through the struct's fields and set the map
for i := 0; i < typ.NumField(); i++ {
p := typ.Field(i)
if !p.Anonymous {
attrs[strings.ToLower(p.Name)] = p
}
}
return attrs
}
|
go
|
func getAttributes(m interface{}) map[string]reflect.StructField {
typ := reflect.TypeOf(m)
// if a pointer to a struct is passed, get the type of the dereferenced object
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
// create an attribute data structure as a map of types keyed by a string.
attrs := make(map[string]reflect.StructField)
// Only structs are supported so return an empty result if the passed object
// isn't a struct
if typ.Kind() != reflect.Struct {
fmt.Printf("%v type can't have attributes inspected\n", typ.Kind())
return attrs
}
// loop through the struct's fields and set the map
for i := 0; i < typ.NumField(); i++ {
p := typ.Field(i)
if !p.Anonymous {
attrs[strings.ToLower(p.Name)] = p
}
}
return attrs
}
|
[
"func",
"getAttributes",
"(",
"m",
"interface",
"{",
"}",
")",
"map",
"[",
"string",
"]",
"reflect",
".",
"StructField",
"{",
"typ",
":=",
"reflect",
".",
"TypeOf",
"(",
"m",
")",
"\n",
"// if a pointer to a struct is passed, get the type of the dereferenced object",
"if",
"typ",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"typ",
"=",
"typ",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n\n",
"// create an attribute data structure as a map of types keyed by a string.",
"attrs",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"reflect",
".",
"StructField",
")",
"\n",
"// Only structs are supported so return an empty result if the passed object",
"// isn't a struct",
"if",
"typ",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"typ",
".",
"Kind",
"(",
")",
")",
"\n",
"return",
"attrs",
"\n",
"}",
"\n\n",
"// loop through the struct's fields and set the map",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"typ",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"p",
":=",
"typ",
".",
"Field",
"(",
"i",
")",
"\n",
"if",
"!",
"p",
".",
"Anonymous",
"{",
"attrs",
"[",
"strings",
".",
"ToLower",
"(",
"p",
".",
"Name",
")",
"]",
"=",
"p",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"attrs",
"\n",
"}"
] |
// Example of how to use Go's reflection
// Print the attributes of a Data Model
|
[
"Example",
"of",
"how",
"to",
"use",
"Go",
"s",
"reflection",
"Print",
"the",
"attributes",
"of",
"a",
"Data",
"Model"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/metadata.go#L506-L531
|
16,159 |
ForceCLI/force
|
lib/deploy.go
|
PushByPaths
|
func PushByPaths(fpaths []string, byName bool, namePaths map[string]string, opts *ForceDeployOptions) {
pb := NewPushBuilder()
var badPaths []string
for _, fpath := range fpaths {
fi, err := os.Stat(fpath)
if err != nil {
fmt.Println(err)
badPaths = append(badPaths, fpath)
continue
}
mode := fi.Mode()
//If path provided is dir we are adding all containing files to deployment
if mode.IsDir() {
dirNamePaths, dirBadPath, err := pb.AddDirectory(fpath)
if err != nil {
fmt.Println(err.Error())
badPaths = append(badPaths, dirBadPath...)
} else {
for dirContentName, dirContentPath := range dirNamePaths {
namePaths[dirContentName] = dirContentPath
}
}
} else if mode.IsRegular() { // single file processing
name, err := pb.AddFile(fpath)
if err != nil {
fmt.Println(err.Error())
badPaths = append(badPaths, fpath)
} else {
// Store paths by name for error messages
namePaths[name] = fpath
}
}
}
if len(badPaths) == 0 {
fmt.Println("Deploying now...")
t0 := time.Now()
deployFiles(pb.ForceMetadataFiles(), byName, namePaths, opts)
t1 := time.Now()
fmt.Printf("The deployment took %v to run.\n", t1.Sub(t0))
} else {
ErrorAndExit("Could not add the following files:\n {%v}", strings.Join(badPaths, "\n"))
}
}
|
go
|
func PushByPaths(fpaths []string, byName bool, namePaths map[string]string, opts *ForceDeployOptions) {
pb := NewPushBuilder()
var badPaths []string
for _, fpath := range fpaths {
fi, err := os.Stat(fpath)
if err != nil {
fmt.Println(err)
badPaths = append(badPaths, fpath)
continue
}
mode := fi.Mode()
//If path provided is dir we are adding all containing files to deployment
if mode.IsDir() {
dirNamePaths, dirBadPath, err := pb.AddDirectory(fpath)
if err != nil {
fmt.Println(err.Error())
badPaths = append(badPaths, dirBadPath...)
} else {
for dirContentName, dirContentPath := range dirNamePaths {
namePaths[dirContentName] = dirContentPath
}
}
} else if mode.IsRegular() { // single file processing
name, err := pb.AddFile(fpath)
if err != nil {
fmt.Println(err.Error())
badPaths = append(badPaths, fpath)
} else {
// Store paths by name for error messages
namePaths[name] = fpath
}
}
}
if len(badPaths) == 0 {
fmt.Println("Deploying now...")
t0 := time.Now()
deployFiles(pb.ForceMetadataFiles(), byName, namePaths, opts)
t1 := time.Now()
fmt.Printf("The deployment took %v to run.\n", t1.Sub(t0))
} else {
ErrorAndExit("Could not add the following files:\n {%v}", strings.Join(badPaths, "\n"))
}
}
|
[
"func",
"PushByPaths",
"(",
"fpaths",
"[",
"]",
"string",
",",
"byName",
"bool",
",",
"namePaths",
"map",
"[",
"string",
"]",
"string",
",",
"opts",
"*",
"ForceDeployOptions",
")",
"{",
"pb",
":=",
"NewPushBuilder",
"(",
")",
"\n",
"var",
"badPaths",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"fpath",
":=",
"range",
"fpaths",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"err",
")",
"\n",
"badPaths",
"=",
"append",
"(",
"badPaths",
",",
"fpath",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"mode",
":=",
"fi",
".",
"Mode",
"(",
")",
"\n",
"//If path provided is dir we are adding all containing files to deployment",
"if",
"mode",
".",
"IsDir",
"(",
")",
"{",
"dirNamePaths",
",",
"dirBadPath",
",",
"err",
":=",
"pb",
".",
"AddDirectory",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"badPaths",
"=",
"append",
"(",
"badPaths",
",",
"dirBadPath",
"...",
")",
"\n",
"}",
"else",
"{",
"for",
"dirContentName",
",",
"dirContentPath",
":=",
"range",
"dirNamePaths",
"{",
"namePaths",
"[",
"dirContentName",
"]",
"=",
"dirContentPath",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"if",
"mode",
".",
"IsRegular",
"(",
")",
"{",
"// single file processing",
"name",
",",
"err",
":=",
"pb",
".",
"AddFile",
"(",
"fpath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"badPaths",
"=",
"append",
"(",
"badPaths",
",",
"fpath",
")",
"\n",
"}",
"else",
"{",
"// Store paths by name for error messages",
"namePaths",
"[",
"name",
"]",
"=",
"fpath",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"badPaths",
")",
"==",
"0",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"t0",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"deployFiles",
"(",
"pb",
".",
"ForceMetadataFiles",
"(",
")",
",",
"byName",
",",
"namePaths",
",",
"opts",
")",
"\n",
"t1",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"t1",
".",
"Sub",
"(",
"t0",
")",
")",
"\n",
"}",
"else",
"{",
"ErrorAndExit",
"(",
"\"",
"\\n",
"\"",
",",
"strings",
".",
"Join",
"(",
"badPaths",
",",
"\"",
"\\n",
"\"",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// Creates a package that includes everything in the passed in string slice
// and then deploys the package to salesforce
|
[
"Creates",
"a",
"package",
"that",
"includes",
"everything",
"in",
"the",
"passed",
"in",
"string",
"slice",
"and",
"then",
"deploys",
"the",
"package",
"to",
"salesforce"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/deploy.go#L17-L62
|
16,160 |
ForceCLI/force
|
lib/deploy.go
|
processDeployResults
|
func processDeployResults(result ForceCheckDeploymentStatusResult, byName bool, namePaths map[string]string, deployErr error) (err error) {
if deployErr != nil {
ErrorAndExit(deployErr.Error())
}
problems := result.Details.ComponentFailures
successes := result.Details.ComponentSuccesses
testFailures := result.Details.RunTestResult.TestFailures
testSuccesses := result.Details.RunTestResult.TestSuccesses
codeCoverageWarnings := result.Details.RunTestResult.CodeCoverageWarnings
if len(successes) > 0 {
fmt.Printf("\nSuccesses - %d\n", len(successes)-1)
for _, success := range successes {
if success.FullName != "package.xml" {
verb := "unchanged"
if success.Changed {
verb = "changed"
} else if success.Deleted {
verb = "deleted"
} else if success.Created {
verb = "created"
}
fmt.Printf("\t%s: %s\n", success.FullName, verb)
}
}
}
fmt.Printf("\nTest Successes - %d\n", len(testSuccesses))
for _, failure := range testSuccesses {
fmt.Printf(" [PASS] %s::%s\n", failure.Name, failure.MethodName)
}
if len(problems) > 0 {
fmt.Printf("\nFailures - %d\n", len(problems))
for _, problem := range problems {
if problem.FullName == "" {
fmt.Println(problem.Problem)
} else {
if byName {
fmt.Printf("ERROR with %s, line %d\n %s\n", problem.FullName, problem.LineNumber, problem.Problem)
} else {
fname, found := namePaths[problem.FullName]
if !found {
fname = problem.FullName
}
fmt.Printf("\"%s\", line %d: %s %s\n", fname, problem.LineNumber, problem.ProblemType, problem.Problem)
}
}
}
}
fmt.Printf("\nTest Failures - %d\n", len(testFailures))
for _, failure := range testFailures {
fmt.Printf("\n [FAIL] %s::%s: %s\n", failure.Name, failure.MethodName, failure.Message)
fmt.Println(failure.StackTrace)
}
if len(codeCoverageWarnings) > 0 {
fmt.Printf("\nCode Coverage Warnings - %d\n", len(codeCoverageWarnings))
for _, warning := range codeCoverageWarnings {
fmt.Printf("\n %s: %s\n", warning.Name, warning.Message)
}
}
// Handle notifications
desktop.NotifySuccess("push", len(problems) == 0)
if len(problems) > 0 {
err = errors.New("Some components failed deployment")
} else if len(testFailures) > 0 {
err = errors.New("Some tests failed")
} else if !result.Success {
err = errors.New(fmt.Sprintf("Status: %s", result.Status))
}
return
}
|
go
|
func processDeployResults(result ForceCheckDeploymentStatusResult, byName bool, namePaths map[string]string, deployErr error) (err error) {
if deployErr != nil {
ErrorAndExit(deployErr.Error())
}
problems := result.Details.ComponentFailures
successes := result.Details.ComponentSuccesses
testFailures := result.Details.RunTestResult.TestFailures
testSuccesses := result.Details.RunTestResult.TestSuccesses
codeCoverageWarnings := result.Details.RunTestResult.CodeCoverageWarnings
if len(successes) > 0 {
fmt.Printf("\nSuccesses - %d\n", len(successes)-1)
for _, success := range successes {
if success.FullName != "package.xml" {
verb := "unchanged"
if success.Changed {
verb = "changed"
} else if success.Deleted {
verb = "deleted"
} else if success.Created {
verb = "created"
}
fmt.Printf("\t%s: %s\n", success.FullName, verb)
}
}
}
fmt.Printf("\nTest Successes - %d\n", len(testSuccesses))
for _, failure := range testSuccesses {
fmt.Printf(" [PASS] %s::%s\n", failure.Name, failure.MethodName)
}
if len(problems) > 0 {
fmt.Printf("\nFailures - %d\n", len(problems))
for _, problem := range problems {
if problem.FullName == "" {
fmt.Println(problem.Problem)
} else {
if byName {
fmt.Printf("ERROR with %s, line %d\n %s\n", problem.FullName, problem.LineNumber, problem.Problem)
} else {
fname, found := namePaths[problem.FullName]
if !found {
fname = problem.FullName
}
fmt.Printf("\"%s\", line %d: %s %s\n", fname, problem.LineNumber, problem.ProblemType, problem.Problem)
}
}
}
}
fmt.Printf("\nTest Failures - %d\n", len(testFailures))
for _, failure := range testFailures {
fmt.Printf("\n [FAIL] %s::%s: %s\n", failure.Name, failure.MethodName, failure.Message)
fmt.Println(failure.StackTrace)
}
if len(codeCoverageWarnings) > 0 {
fmt.Printf("\nCode Coverage Warnings - %d\n", len(codeCoverageWarnings))
for _, warning := range codeCoverageWarnings {
fmt.Printf("\n %s: %s\n", warning.Name, warning.Message)
}
}
// Handle notifications
desktop.NotifySuccess("push", len(problems) == 0)
if len(problems) > 0 {
err = errors.New("Some components failed deployment")
} else if len(testFailures) > 0 {
err = errors.New("Some tests failed")
} else if !result.Success {
err = errors.New(fmt.Sprintf("Status: %s", result.Status))
}
return
}
|
[
"func",
"processDeployResults",
"(",
"result",
"ForceCheckDeploymentStatusResult",
",",
"byName",
"bool",
",",
"namePaths",
"map",
"[",
"string",
"]",
"string",
",",
"deployErr",
"error",
")",
"(",
"err",
"error",
")",
"{",
"if",
"deployErr",
"!=",
"nil",
"{",
"ErrorAndExit",
"(",
"deployErr",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"problems",
":=",
"result",
".",
"Details",
".",
"ComponentFailures",
"\n",
"successes",
":=",
"result",
".",
"Details",
".",
"ComponentSuccesses",
"\n",
"testFailures",
":=",
"result",
".",
"Details",
".",
"RunTestResult",
".",
"TestFailures",
"\n",
"testSuccesses",
":=",
"result",
".",
"Details",
".",
"RunTestResult",
".",
"TestSuccesses",
"\n",
"codeCoverageWarnings",
":=",
"result",
".",
"Details",
".",
"RunTestResult",
".",
"CodeCoverageWarnings",
"\n\n",
"if",
"len",
"(",
"successes",
")",
">",
"0",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"len",
"(",
"successes",
")",
"-",
"1",
")",
"\n",
"for",
"_",
",",
"success",
":=",
"range",
"successes",
"{",
"if",
"success",
".",
"FullName",
"!=",
"\"",
"\"",
"{",
"verb",
":=",
"\"",
"\"",
"\n",
"if",
"success",
".",
"Changed",
"{",
"verb",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"if",
"success",
".",
"Deleted",
"{",
"verb",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"if",
"success",
".",
"Created",
"{",
"verb",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\t",
"\\n",
"\"",
",",
"success",
".",
"FullName",
",",
"verb",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"len",
"(",
"testSuccesses",
")",
")",
"\n",
"for",
"_",
",",
"failure",
":=",
"range",
"testSuccesses",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"failure",
".",
"Name",
",",
"failure",
".",
"MethodName",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"problems",
")",
">",
"0",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"len",
"(",
"problems",
")",
")",
"\n",
"for",
"_",
",",
"problem",
":=",
"range",
"problems",
"{",
"if",
"problem",
".",
"FullName",
"==",
"\"",
"\"",
"{",
"fmt",
".",
"Println",
"(",
"problem",
".",
"Problem",
")",
"\n",
"}",
"else",
"{",
"if",
"byName",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"problem",
".",
"FullName",
",",
"problem",
".",
"LineNumber",
",",
"problem",
".",
"Problem",
")",
"\n",
"}",
"else",
"{",
"fname",
",",
"found",
":=",
"namePaths",
"[",
"problem",
".",
"FullName",
"]",
"\n",
"if",
"!",
"found",
"{",
"fname",
"=",
"problem",
".",
"FullName",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\\"",
"\\\"",
"\\n",
"\"",
",",
"fname",
",",
"problem",
".",
"LineNumber",
",",
"problem",
".",
"ProblemType",
",",
"problem",
".",
"Problem",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"len",
"(",
"testFailures",
")",
")",
"\n",
"for",
"_",
",",
"failure",
":=",
"range",
"testFailures",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"failure",
".",
"Name",
",",
"failure",
".",
"MethodName",
",",
"failure",
".",
"Message",
")",
"\n",
"fmt",
".",
"Println",
"(",
"failure",
".",
"StackTrace",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"codeCoverageWarnings",
")",
">",
"0",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"len",
"(",
"codeCoverageWarnings",
")",
")",
"\n",
"for",
"_",
",",
"warning",
":=",
"range",
"codeCoverageWarnings",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"warning",
".",
"Name",
",",
"warning",
".",
"Message",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Handle notifications",
"desktop",
".",
"NotifySuccess",
"(",
"\"",
"\"",
",",
"len",
"(",
"problems",
")",
"==",
"0",
")",
"\n",
"if",
"len",
"(",
"problems",
")",
">",
"0",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"testFailures",
")",
">",
"0",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"!",
"result",
".",
"Success",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"result",
".",
"Status",
")",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Process and display the result of the push operation
|
[
"Process",
"and",
"display",
"the",
"result",
"of",
"the",
"push",
"operation"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/deploy.go#L75-L150
|
16,161 |
ForceCLI/force
|
lib/force.go
|
qualifyUrl
|
func (f *Force) qualifyUrl(url string) string {
return fmt.Sprintf("%s/%s", f.Credentials.InstanceUrl, strings.TrimLeft(url, "/"))
}
|
go
|
func (f *Force) qualifyUrl(url string) string {
return fmt.Sprintf("%s/%s", f.Credentials.InstanceUrl, strings.TrimLeft(url, "/"))
}
|
[
"func",
"(",
"f",
"*",
"Force",
")",
"qualifyUrl",
"(",
"url",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"f",
".",
"Credentials",
".",
"InstanceUrl",
",",
"strings",
".",
"TrimLeft",
"(",
"url",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] |
// Prepend https schema and instance to URL
|
[
"Prepend",
"https",
"schema",
"and",
"instance",
"to",
"URL"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/force.go#L1224-L1226
|
16,162 |
ForceCLI/force
|
config/config.go
|
IsSourceDir
|
func IsSourceDir(dir string) bool {
if _, err := os.Stat(dir); err == nil {
return true
}
return false
}
|
go
|
func IsSourceDir(dir string) bool {
if _, err := os.Stat(dir); err == nil {
return true
}
return false
}
|
[
"func",
"IsSourceDir",
"(",
"dir",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// IsSourceDir returns a boolean indicating that dir is actually a Salesforce
// source directory.
|
[
"IsSourceDir",
"returns",
"a",
"boolean",
"indicating",
"that",
"dir",
"is",
"actually",
"a",
"Salesforce",
"source",
"directory",
"."
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/config/config.go#L19-L24
|
16,163 |
ForceCLI/force
|
config/config.go
|
GetSourceDir
|
func GetSourceDir() (dir string, err error) {
base, err := os.Getwd()
if err != nil {
return
}
// Look down to our nearest subdirectories
for _, src := range sourceDirs {
if len(src) > 0 {
dir = filepath.Join(base, src)
if IsSourceDir(dir) {
return
}
}
}
// Check the current directory and then start looking up at our parents.
// When dir's parent is identical, it means we're at the root. If we blow
// past the actual root, we should drop to the next section of code
for dir != filepath.Dir(dir) {
dir = filepath.Dir(dir)
for _, src := range sourceDirs {
adir := filepath.Join(dir, src)
if IsSourceDir(adir) {
dir = adir
return
}
}
}
// No source directory found, create a src directory and a symlinked "metadata"
// directory for backward compatibility and return that.
dir = filepath.Join(base, "src")
err = os.Mkdir(dir, 0777)
symlink := filepath.Join(base, "metadata")
os.Symlink(dir, symlink)
dir = symlink
return
}
|
go
|
func GetSourceDir() (dir string, err error) {
base, err := os.Getwd()
if err != nil {
return
}
// Look down to our nearest subdirectories
for _, src := range sourceDirs {
if len(src) > 0 {
dir = filepath.Join(base, src)
if IsSourceDir(dir) {
return
}
}
}
// Check the current directory and then start looking up at our parents.
// When dir's parent is identical, it means we're at the root. If we blow
// past the actual root, we should drop to the next section of code
for dir != filepath.Dir(dir) {
dir = filepath.Dir(dir)
for _, src := range sourceDirs {
adir := filepath.Join(dir, src)
if IsSourceDir(adir) {
dir = adir
return
}
}
}
// No source directory found, create a src directory and a symlinked "metadata"
// directory for backward compatibility and return that.
dir = filepath.Join(base, "src")
err = os.Mkdir(dir, 0777)
symlink := filepath.Join(base, "metadata")
os.Symlink(dir, symlink)
dir = symlink
return
}
|
[
"func",
"GetSourceDir",
"(",
")",
"(",
"dir",
"string",
",",
"err",
"error",
")",
"{",
"base",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"// Look down to our nearest subdirectories",
"for",
"_",
",",
"src",
":=",
"range",
"sourceDirs",
"{",
"if",
"len",
"(",
"src",
")",
">",
"0",
"{",
"dir",
"=",
"filepath",
".",
"Join",
"(",
"base",
",",
"src",
")",
"\n",
"if",
"IsSourceDir",
"(",
"dir",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Check the current directory and then start looking up at our parents.",
"// When dir's parent is identical, it means we're at the root. If we blow",
"// past the actual root, we should drop to the next section of code",
"for",
"dir",
"!=",
"filepath",
".",
"Dir",
"(",
"dir",
")",
"{",
"dir",
"=",
"filepath",
".",
"Dir",
"(",
"dir",
")",
"\n",
"for",
"_",
",",
"src",
":=",
"range",
"sourceDirs",
"{",
"adir",
":=",
"filepath",
".",
"Join",
"(",
"dir",
",",
"src",
")",
"\n",
"if",
"IsSourceDir",
"(",
"adir",
")",
"{",
"dir",
"=",
"adir",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// No source directory found, create a src directory and a symlinked \"metadata\"",
"// directory for backward compatibility and return that.",
"dir",
"=",
"filepath",
".",
"Join",
"(",
"base",
",",
"\"",
"\"",
")",
"\n",
"err",
"=",
"os",
".",
"Mkdir",
"(",
"dir",
",",
"0777",
")",
"\n",
"symlink",
":=",
"filepath",
".",
"Join",
"(",
"base",
",",
"\"",
"\"",
")",
"\n",
"os",
".",
"Symlink",
"(",
"dir",
",",
"symlink",
")",
"\n",
"dir",
"=",
"symlink",
"\n",
"return",
"\n",
"}"
] |
// GetSourceDir returns a rooted path name of the Salesforce source directory,
// relative to the current directory. GetSourceDir will look for a source
// directory in the nearest subdirectory. If no such directory exists, it will
// look at its parents, assuming that it is within a source directory already.
|
[
"GetSourceDir",
"returns",
"a",
"rooted",
"path",
"name",
"of",
"the",
"Salesforce",
"source",
"directory",
"relative",
"to",
"the",
"current",
"directory",
".",
"GetSourceDir",
"will",
"look",
"for",
"a",
"source",
"directory",
"in",
"the",
"nearest",
"subdirectory",
".",
"If",
"no",
"such",
"directory",
"exists",
"it",
"will",
"look",
"at",
"its",
"parents",
"assuming",
"that",
"it",
"is",
"within",
"a",
"source",
"directory",
"already",
"."
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/config/config.go#L30-L68
|
16,164 |
ForceCLI/force
|
lib/display.go
|
StringSlicePos
|
func StringSlicePos(slice []string, value string) int {
for p, v := range slice {
if v == value {
return p
}
}
return -1
}
|
go
|
func StringSlicePos(slice []string, value string) int {
for p, v := range slice {
if v == value {
return p
}
}
return -1
}
|
[
"func",
"StringSlicePos",
"(",
"slice",
"[",
"]",
"string",
",",
"value",
"string",
")",
"int",
"{",
"for",
"p",
",",
"v",
":=",
"range",
"slice",
"{",
"if",
"v",
"==",
"value",
"{",
"return",
"p",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"-",
"1",
"\n",
"}"
] |
// returns first index of a given string
|
[
"returns",
"first",
"index",
"of",
"a",
"given",
"string"
] |
dcf4021894573897981e05f26e1282dd209519e2
|
https://github.com/ForceCLI/force/blob/dcf4021894573897981e05f26e1282dd209519e2/lib/display.go#L357-L364
|
16,165 |
neurosnap/sentences
|
token.go
|
Group
|
func (p *DefaultTokenGrouper) Group(tokens []*Token) [][2]*Token {
if len(tokens) == 0 {
return nil
}
pairTokens := make([][2]*Token, 0, len(tokens))
prevToken := tokens[0]
for _, tok := range tokens {
if prevToken == tok {
continue
}
pairTokens = append(pairTokens, [2]*Token{prevToken, tok})
prevToken = tok
}
pairTokens = append(pairTokens, [2]*Token{prevToken, nil})
return pairTokens
}
|
go
|
func (p *DefaultTokenGrouper) Group(tokens []*Token) [][2]*Token {
if len(tokens) == 0 {
return nil
}
pairTokens := make([][2]*Token, 0, len(tokens))
prevToken := tokens[0]
for _, tok := range tokens {
if prevToken == tok {
continue
}
pairTokens = append(pairTokens, [2]*Token{prevToken, tok})
prevToken = tok
}
pairTokens = append(pairTokens, [2]*Token{prevToken, nil})
return pairTokens
}
|
[
"func",
"(",
"p",
"*",
"DefaultTokenGrouper",
")",
"Group",
"(",
"tokens",
"[",
"]",
"*",
"Token",
")",
"[",
"]",
"[",
"2",
"]",
"*",
"Token",
"{",
"if",
"len",
"(",
"tokens",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"pairTokens",
":=",
"make",
"(",
"[",
"]",
"[",
"2",
"]",
"*",
"Token",
",",
"0",
",",
"len",
"(",
"tokens",
")",
")",
"\n\n",
"prevToken",
":=",
"tokens",
"[",
"0",
"]",
"\n",
"for",
"_",
",",
"tok",
":=",
"range",
"tokens",
"{",
"if",
"prevToken",
"==",
"tok",
"{",
"continue",
"\n",
"}",
"\n",
"pairTokens",
"=",
"append",
"(",
"pairTokens",
",",
"[",
"2",
"]",
"*",
"Token",
"{",
"prevToken",
",",
"tok",
"}",
")",
"\n",
"prevToken",
"=",
"tok",
"\n",
"}",
"\n",
"pairTokens",
"=",
"append",
"(",
"pairTokens",
",",
"[",
"2",
"]",
"*",
"Token",
"{",
"prevToken",
",",
"nil",
"}",
")",
"\n\n",
"return",
"pairTokens",
"\n",
"}"
] |
// Group is the primary logic for implementing TokenGrouper
|
[
"Group",
"is",
"the",
"primary",
"logic",
"for",
"implementing",
"TokenGrouper"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/token.go#L17-L35
|
16,166 |
neurosnap/sentences
|
token.go
|
NewToken
|
func NewToken(token string) *Token {
tok := Token{
Tok: token,
reEllipsis: reEllipsis,
reNumeric: reNumeric,
reInitial: reInitial,
reAlpha: reAlpha,
}
return &tok
}
|
go
|
func NewToken(token string) *Token {
tok := Token{
Tok: token,
reEllipsis: reEllipsis,
reNumeric: reNumeric,
reInitial: reInitial,
reAlpha: reAlpha,
}
return &tok
}
|
[
"func",
"NewToken",
"(",
"token",
"string",
")",
"*",
"Token",
"{",
"tok",
":=",
"Token",
"{",
"Tok",
":",
"token",
",",
"reEllipsis",
":",
"reEllipsis",
",",
"reNumeric",
":",
"reNumeric",
",",
"reInitial",
":",
"reInitial",
",",
"reAlpha",
":",
"reAlpha",
",",
"}",
"\n\n",
"return",
"&",
"tok",
"\n",
"}"
] |
// NewToken is the default implementation of the Token struct
|
[
"NewToken",
"is",
"the",
"default",
"implementation",
"of",
"the",
"Token",
"struct"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/token.go#L58-L68
|
16,167 |
neurosnap/sentences
|
token.go
|
String
|
func (p *Token) String() string {
return fmt.Sprintf("<Token Tok: %q, SentBreak: %t, Abbr: %t, Position: %d>", p.Tok, p.SentBreak, p.Abbr, p.Position)
}
|
go
|
func (p *Token) String() string {
return fmt.Sprintf("<Token Tok: %q, SentBreak: %t, Abbr: %t, Position: %d>", p.Tok, p.SentBreak, p.Abbr, p.Position)
}
|
[
"func",
"(",
"p",
"*",
"Token",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"Tok",
",",
"p",
".",
"SentBreak",
",",
"p",
".",
"Abbr",
",",
"p",
".",
"Position",
")",
"\n",
"}"
] |
// String is the string representation of Token
|
[
"String",
"is",
"the",
"string",
"representation",
"of",
"Token"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/token.go#L71-L73
|
16,168 |
neurosnap/sentences
|
utils/frequency_dist.go
|
N
|
func (f *FreqDist) N() float64 {
sum := 0.0
for _, val := range f.Samples {
sum += float64(val)
}
return sum
}
|
go
|
func (f *FreqDist) N() float64 {
sum := 0.0
for _, val := range f.Samples {
sum += float64(val)
}
return sum
}
|
[
"func",
"(",
"f",
"*",
"FreqDist",
")",
"N",
"(",
")",
"float64",
"{",
"sum",
":=",
"0.0",
"\n",
"for",
"_",
",",
"val",
":=",
"range",
"f",
".",
"Samples",
"{",
"sum",
"+=",
"float64",
"(",
"val",
")",
"\n",
"}",
"\n",
"return",
"sum",
"\n",
"}"
] |
// N returns the total number of sample outcomes that have been recorded by this FreqDist.
|
[
"N",
"returns",
"the",
"total",
"number",
"of",
"sample",
"outcomes",
"that",
"have",
"been",
"recorded",
"by",
"this",
"FreqDist",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/utils/frequency_dist.go#L26-L32
|
16,169 |
neurosnap/sentences
|
utils/frequency_dist.go
|
rToNr
|
func (f *FreqDist) rToNr(bins int) map[int]int {
tmpRToNr := map[int]int{}
for _, value := range f.Samples {
tmpRToNr[value] += 1
}
if bins == 0 {
tmpRToNr[0] = 0
} else {
tmpRToNr[0] = bins - f.B()
}
return tmpRToNr
}
|
go
|
func (f *FreqDist) rToNr(bins int) map[int]int {
tmpRToNr := map[int]int{}
for _, value := range f.Samples {
tmpRToNr[value] += 1
}
if bins == 0 {
tmpRToNr[0] = 0
} else {
tmpRToNr[0] = bins - f.B()
}
return tmpRToNr
}
|
[
"func",
"(",
"f",
"*",
"FreqDist",
")",
"rToNr",
"(",
"bins",
"int",
")",
"map",
"[",
"int",
"]",
"int",
"{",
"tmpRToNr",
":=",
"map",
"[",
"int",
"]",
"int",
"{",
"}",
"\n\n",
"for",
"_",
",",
"value",
":=",
"range",
"f",
".",
"Samples",
"{",
"tmpRToNr",
"[",
"value",
"]",
"+=",
"1",
"\n",
"}",
"\n\n",
"if",
"bins",
"==",
"0",
"{",
"tmpRToNr",
"[",
"0",
"]",
"=",
"0",
"\n",
"}",
"else",
"{",
"tmpRToNr",
"[",
"0",
"]",
"=",
"bins",
"-",
"f",
".",
"B",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"tmpRToNr",
"\n",
"}"
] |
// Return the dictionary mapping r to Nr, the number of Samples with frequency r, where Nr > 0
|
[
"Return",
"the",
"dictionary",
"mapping",
"r",
"to",
"Nr",
"the",
"number",
"of",
"Samples",
"with",
"frequency",
"r",
"where",
"Nr",
">",
"0"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/utils/frequency_dist.go#L54-L68
|
16,170 |
neurosnap/sentences
|
utils/frequency_dist.go
|
cumulativeFrequencies
|
func (f *FreqDist) cumulativeFrequencies(Samples []string) []int {
cf := make([]int, 0, len(f.Samples))
for _, val := range Samples {
cf = append(cf, f.Samples[val])
}
return cf
}
|
go
|
func (f *FreqDist) cumulativeFrequencies(Samples []string) []int {
cf := make([]int, 0, len(f.Samples))
for _, val := range Samples {
cf = append(cf, f.Samples[val])
}
return cf
}
|
[
"func",
"(",
"f",
"*",
"FreqDist",
")",
"cumulativeFrequencies",
"(",
"Samples",
"[",
"]",
"string",
")",
"[",
"]",
"int",
"{",
"cf",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"0",
",",
"len",
"(",
"f",
".",
"Samples",
")",
")",
"\n\n",
"for",
"_",
",",
"val",
":=",
"range",
"Samples",
"{",
"cf",
"=",
"append",
"(",
"cf",
",",
"f",
".",
"Samples",
"[",
"val",
"]",
")",
"\n",
"}",
"\n\n",
"return",
"cf",
"\n",
"}"
] |
// Return the cumulative frequencies of the specified Samples.
// If no Samples are specified, all counts are returned, starting with the largest.
|
[
"Return",
"the",
"cumulative",
"frequencies",
"of",
"the",
"specified",
"Samples",
".",
"If",
"no",
"Samples",
"are",
"specified",
"all",
"counts",
"are",
"returned",
"starting",
"with",
"the",
"largest",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/utils/frequency_dist.go#L72-L80
|
16,171 |
neurosnap/sentences
|
punctuation.go
|
HasSentencePunct
|
func (p *DefaultPunctStrings) HasSentencePunct(text string) bool {
endPunct := `.!?`
for _, char := range endPunct {
for _, achar := range text {
if char == achar {
return true
}
}
}
return false
}
|
go
|
func (p *DefaultPunctStrings) HasSentencePunct(text string) bool {
endPunct := `.!?`
for _, char := range endPunct {
for _, achar := range text {
if char == achar {
return true
}
}
}
return false
}
|
[
"func",
"(",
"p",
"*",
"DefaultPunctStrings",
")",
"HasSentencePunct",
"(",
"text",
"string",
")",
"bool",
"{",
"endPunct",
":=",
"`.!?`",
"\n",
"for",
"_",
",",
"char",
":=",
"range",
"endPunct",
"{",
"for",
"_",
",",
"achar",
":=",
"range",
"text",
"{",
"if",
"char",
"==",
"achar",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// HasSentencePunct does the supplied text have a known sentence punctuation character?
|
[
"HasSentencePunct",
"does",
"the",
"supplied",
"text",
"have",
"a",
"known",
"sentence",
"punctuation",
"character?"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/punctuation.go#L32-L43
|
16,172 |
neurosnap/sentences
|
annotate.go
|
NewTypeBasedAnnotation
|
func NewTypeBasedAnnotation(s *Storage, p PunctStrings, e TokenExistential) *TypeBasedAnnotation {
return &TypeBasedAnnotation{
Storage: s,
PunctStrings: p,
TokenExistential: e,
}
}
|
go
|
func NewTypeBasedAnnotation(s *Storage, p PunctStrings, e TokenExistential) *TypeBasedAnnotation {
return &TypeBasedAnnotation{
Storage: s,
PunctStrings: p,
TokenExistential: e,
}
}
|
[
"func",
"NewTypeBasedAnnotation",
"(",
"s",
"*",
"Storage",
",",
"p",
"PunctStrings",
",",
"e",
"TokenExistential",
")",
"*",
"TypeBasedAnnotation",
"{",
"return",
"&",
"TypeBasedAnnotation",
"{",
"Storage",
":",
"s",
",",
"PunctStrings",
":",
"p",
",",
"TokenExistential",
":",
"e",
",",
"}",
"\n",
"}"
] |
// NewTypeBasedAnnotation creates an instance of the TypeBasedAnnotation struct
|
[
"NewTypeBasedAnnotation",
"creates",
"an",
"instance",
"of",
"the",
"TypeBasedAnnotation",
"struct"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/annotate.go#L35-L41
|
16,173 |
neurosnap/sentences
|
annotate.go
|
NewAnnotations
|
func NewAnnotations(s *Storage, p PunctStrings, word WordTokenizer) []AnnotateTokens {
return []AnnotateTokens{
&TypeBasedAnnotation{s, p, word},
&TokenBasedAnnotation{s, p, word, &DefaultTokenGrouper{}, &OrthoContext{
s, p, word, word,
}},
}
}
|
go
|
func NewAnnotations(s *Storage, p PunctStrings, word WordTokenizer) []AnnotateTokens {
return []AnnotateTokens{
&TypeBasedAnnotation{s, p, word},
&TokenBasedAnnotation{s, p, word, &DefaultTokenGrouper{}, &OrthoContext{
s, p, word, word,
}},
}
}
|
[
"func",
"NewAnnotations",
"(",
"s",
"*",
"Storage",
",",
"p",
"PunctStrings",
",",
"word",
"WordTokenizer",
")",
"[",
"]",
"AnnotateTokens",
"{",
"return",
"[",
"]",
"AnnotateTokens",
"{",
"&",
"TypeBasedAnnotation",
"{",
"s",
",",
"p",
",",
"word",
"}",
",",
"&",
"TokenBasedAnnotation",
"{",
"s",
",",
"p",
",",
"word",
",",
"&",
"DefaultTokenGrouper",
"{",
"}",
",",
"&",
"OrthoContext",
"{",
"s",
",",
"p",
",",
"word",
",",
"word",
",",
"}",
"}",
",",
"}",
"\n",
"}"
] |
// NewAnnotations is the default AnnotateTokens struct that the tokenizer uses
|
[
"NewAnnotations",
"is",
"the",
"default",
"AnnotateTokens",
"struct",
"that",
"the",
"tokenizer",
"uses"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/annotate.go#L44-L51
|
16,174 |
neurosnap/sentences
|
annotate.go
|
Annotate
|
func (a *TypeBasedAnnotation) Annotate(tokens []*Token) []*Token {
for _, augTok := range tokens {
a.typeAnnotation(augTok)
}
return tokens
}
|
go
|
func (a *TypeBasedAnnotation) Annotate(tokens []*Token) []*Token {
for _, augTok := range tokens {
a.typeAnnotation(augTok)
}
return tokens
}
|
[
"func",
"(",
"a",
"*",
"TypeBasedAnnotation",
")",
"Annotate",
"(",
"tokens",
"[",
"]",
"*",
"Token",
")",
"[",
"]",
"*",
"Token",
"{",
"for",
"_",
",",
"augTok",
":=",
"range",
"tokens",
"{",
"a",
".",
"typeAnnotation",
"(",
"augTok",
")",
"\n",
"}",
"\n",
"return",
"tokens",
"\n",
"}"
] |
// Annotate iterates over all tokens and applies the type annotation on them
|
[
"Annotate",
"iterates",
"over",
"all",
"tokens",
"and",
"applies",
"the",
"type",
"annotation",
"on",
"them"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/annotate.go#L54-L59
|
16,175 |
neurosnap/sentences
|
annotate.go
|
Annotate
|
func (a *TokenBasedAnnotation) Annotate(tokens []*Token) []*Token {
for _, tokPair := range a.TokenGrouper.Group(tokens) {
a.tokenAnnotation(tokPair[0], tokPair[1])
}
return tokens
}
|
go
|
func (a *TokenBasedAnnotation) Annotate(tokens []*Token) []*Token {
for _, tokPair := range a.TokenGrouper.Group(tokens) {
a.tokenAnnotation(tokPair[0], tokPair[1])
}
return tokens
}
|
[
"func",
"(",
"a",
"*",
"TokenBasedAnnotation",
")",
"Annotate",
"(",
"tokens",
"[",
"]",
"*",
"Token",
")",
"[",
"]",
"*",
"Token",
"{",
"for",
"_",
",",
"tokPair",
":=",
"range",
"a",
".",
"TokenGrouper",
".",
"Group",
"(",
"tokens",
")",
"{",
"a",
".",
"tokenAnnotation",
"(",
"tokPair",
"[",
"0",
"]",
",",
"tokPair",
"[",
"1",
"]",
")",
"\n",
"}",
"\n\n",
"return",
"tokens",
"\n",
"}"
] |
// Annotate iterates groups tokens in pairs of two and then iterates over them to apply token annotation
|
[
"Annotate",
"iterates",
"groups",
"tokens",
"in",
"pairs",
"of",
"two",
"and",
"then",
"iterates",
"over",
"them",
"to",
"apply",
"token",
"annotation"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/annotate.go#L93-L99
|
16,176 |
neurosnap/sentences
|
sentence_tokenizer.go
|
NewSentenceTokenizer
|
func NewSentenceTokenizer(s *Storage) *DefaultSentenceTokenizer {
lang := NewPunctStrings()
word := NewWordTokenizer(lang)
annotations := NewAnnotations(s, lang, word)
tokenizer := &DefaultSentenceTokenizer{
Storage: s,
PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
return tokenizer
}
|
go
|
func NewSentenceTokenizer(s *Storage) *DefaultSentenceTokenizer {
lang := NewPunctStrings()
word := NewWordTokenizer(lang)
annotations := NewAnnotations(s, lang, word)
tokenizer := &DefaultSentenceTokenizer{
Storage: s,
PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
return tokenizer
}
|
[
"func",
"NewSentenceTokenizer",
"(",
"s",
"*",
"Storage",
")",
"*",
"DefaultSentenceTokenizer",
"{",
"lang",
":=",
"NewPunctStrings",
"(",
")",
"\n",
"word",
":=",
"NewWordTokenizer",
"(",
"lang",
")",
"\n\n",
"annotations",
":=",
"NewAnnotations",
"(",
"s",
",",
"lang",
",",
"word",
")",
"\n\n",
"tokenizer",
":=",
"&",
"DefaultSentenceTokenizer",
"{",
"Storage",
":",
"s",
",",
"PunctStrings",
":",
"lang",
",",
"WordTokenizer",
":",
"word",
",",
"Annotations",
":",
"annotations",
",",
"}",
"\n\n",
"return",
"tokenizer",
"\n\n",
"}"
] |
// NewSentenceTokenizer are the sane defaults for the sentence tokenizer
|
[
"NewSentenceTokenizer",
"are",
"the",
"sane",
"defaults",
"for",
"the",
"sentence",
"tokenizer"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/sentence_tokenizer.go#L23-L38
|
16,177 |
neurosnap/sentences
|
sentence_tokenizer.go
|
NewTokenizer
|
func NewTokenizer(s *Storage, word WordTokenizer, lang PunctStrings) *DefaultSentenceTokenizer {
annotations := NewAnnotations(s, lang, word)
tokenizer := &DefaultSentenceTokenizer{
Storage: s,
PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
return tokenizer
}
|
go
|
func NewTokenizer(s *Storage, word WordTokenizer, lang PunctStrings) *DefaultSentenceTokenizer {
annotations := NewAnnotations(s, lang, word)
tokenizer := &DefaultSentenceTokenizer{
Storage: s,
PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
return tokenizer
}
|
[
"func",
"NewTokenizer",
"(",
"s",
"*",
"Storage",
",",
"word",
"WordTokenizer",
",",
"lang",
"PunctStrings",
")",
"*",
"DefaultSentenceTokenizer",
"{",
"annotations",
":=",
"NewAnnotations",
"(",
"s",
",",
"lang",
",",
"word",
")",
"\n\n",
"tokenizer",
":=",
"&",
"DefaultSentenceTokenizer",
"{",
"Storage",
":",
"s",
",",
"PunctStrings",
":",
"lang",
",",
"WordTokenizer",
":",
"word",
",",
"Annotations",
":",
"annotations",
",",
"}",
"\n\n",
"return",
"tokenizer",
"\n",
"}"
] |
// NewTokenizer wraps around DST doing the work for customizing the tokenizer
|
[
"NewTokenizer",
"wraps",
"around",
"DST",
"doing",
"the",
"work",
"for",
"customizing",
"the",
"tokenizer"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/sentence_tokenizer.go#L41-L52
|
16,178 |
neurosnap/sentences
|
sentence_tokenizer.go
|
Tokenize
|
func (s *DefaultSentenceTokenizer) Tokenize(text string) []*Sentence {
annotatedTokens := s.AnnotatedTokens(text)
lastBreak := 0
sentences := make([]*Sentence, 0, len(annotatedTokens))
for _, token := range annotatedTokens {
if !token.SentBreak {
continue
}
sentence := &Sentence{lastBreak, token.Position, text[lastBreak:token.Position]}
sentences = append(sentences, sentence)
lastBreak = token.Position
}
if lastBreak != len(text) {
lastChar := len(text)
sentence := &Sentence{lastBreak, lastChar, text[lastBreak:lastChar]}
sentences = append(sentences, sentence)
}
return sentences
}
|
go
|
func (s *DefaultSentenceTokenizer) Tokenize(text string) []*Sentence {
annotatedTokens := s.AnnotatedTokens(text)
lastBreak := 0
sentences := make([]*Sentence, 0, len(annotatedTokens))
for _, token := range annotatedTokens {
if !token.SentBreak {
continue
}
sentence := &Sentence{lastBreak, token.Position, text[lastBreak:token.Position]}
sentences = append(sentences, sentence)
lastBreak = token.Position
}
if lastBreak != len(text) {
lastChar := len(text)
sentence := &Sentence{lastBreak, lastChar, text[lastBreak:lastChar]}
sentences = append(sentences, sentence)
}
return sentences
}
|
[
"func",
"(",
"s",
"*",
"DefaultSentenceTokenizer",
")",
"Tokenize",
"(",
"text",
"string",
")",
"[",
"]",
"*",
"Sentence",
"{",
"annotatedTokens",
":=",
"s",
".",
"AnnotatedTokens",
"(",
"text",
")",
"\n\n",
"lastBreak",
":=",
"0",
"\n",
"sentences",
":=",
"make",
"(",
"[",
"]",
"*",
"Sentence",
",",
"0",
",",
"len",
"(",
"annotatedTokens",
")",
")",
"\n",
"for",
"_",
",",
"token",
":=",
"range",
"annotatedTokens",
"{",
"if",
"!",
"token",
".",
"SentBreak",
"{",
"continue",
"\n",
"}",
"\n\n",
"sentence",
":=",
"&",
"Sentence",
"{",
"lastBreak",
",",
"token",
".",
"Position",
",",
"text",
"[",
"lastBreak",
":",
"token",
".",
"Position",
"]",
"}",
"\n",
"sentences",
"=",
"append",
"(",
"sentences",
",",
"sentence",
")",
"\n\n",
"lastBreak",
"=",
"token",
".",
"Position",
"\n",
"}",
"\n\n",
"if",
"lastBreak",
"!=",
"len",
"(",
"text",
")",
"{",
"lastChar",
":=",
"len",
"(",
"text",
")",
"\n",
"sentence",
":=",
"&",
"Sentence",
"{",
"lastBreak",
",",
"lastChar",
",",
"text",
"[",
"lastBreak",
":",
"lastChar",
"]",
"}",
"\n",
"sentences",
"=",
"append",
"(",
"sentences",
",",
"sentence",
")",
"\n",
"}",
"\n\n",
"return",
"sentences",
"\n",
"}"
] |
// Tokenize splits text input into sentence tokens.
|
[
"Tokenize",
"splits",
"text",
"input",
"into",
"sentence",
"tokens",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/sentence_tokenizer.go#L120-L143
|
16,179 |
neurosnap/sentences
|
english/main.go
|
HasSentEndChars
|
func (e *WordTokenizer) HasSentEndChars(t *sentences.Token) bool {
enders := []string{
`."`, `.'`, `.)`, `.’`, `.”`,
`?`, `?"`, `?'`, `?)`, `?’`, `?”`,
`!`, `!"`, `!'`, `!)`, `!’`, `!”`,
}
for _, ender := range enders {
if strings.HasSuffix(t.Tok, ender) {
return true
}
}
parens := []string{
`.[`, `.(`, `."`, `.'`,
`?[`, `?(`,
`![`, `!(`,
}
for _, paren := range parens {
if strings.Index(t.Tok, paren) != -1 {
return true
}
}
return false
}
|
go
|
func (e *WordTokenizer) HasSentEndChars(t *sentences.Token) bool {
enders := []string{
`."`, `.'`, `.)`, `.’`, `.”`,
`?`, `?"`, `?'`, `?)`, `?’`, `?”`,
`!`, `!"`, `!'`, `!)`, `!’`, `!”`,
}
for _, ender := range enders {
if strings.HasSuffix(t.Tok, ender) {
return true
}
}
parens := []string{
`.[`, `.(`, `."`, `.'`,
`?[`, `?(`,
`![`, `!(`,
}
for _, paren := range parens {
if strings.Index(t.Tok, paren) != -1 {
return true
}
}
return false
}
|
[
"func",
"(",
"e",
"*",
"WordTokenizer",
")",
"HasSentEndChars",
"(",
"t",
"*",
"sentences",
".",
"Token",
")",
"bool",
"{",
"enders",
":=",
"[",
"]",
"string",
"{",
"`.\"`",
",",
"`.'`",
",",
"`.)`",
",",
"`.’`, ",
"`",
"”`,",
"",
"`?`",
",",
"`?\"`",
",",
"`?'`",
",",
"`?)`",
",",
"`?’`, ",
"`",
"”`,",
"",
"`!`",
",",
"`!\"`",
",",
"`!'`",
",",
"`!)`",
",",
"`!’`, ",
"`",
"”`,",
"",
"}",
"\n\n",
"for",
"_",
",",
"ender",
":=",
"range",
"enders",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"t",
".",
"Tok",
",",
"ender",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"parens",
":=",
"[",
"]",
"string",
"{",
"`.[`",
",",
"`.(`",
",",
"`.\"`",
",",
"`.'`",
",",
"`?[`",
",",
"`?(`",
",",
"`![`",
",",
"`!(`",
",",
"}",
"\n\n",
"for",
"_",
",",
"paren",
":=",
"range",
"parens",
"{",
"if",
"strings",
".",
"Index",
"(",
"t",
".",
"Tok",
",",
"paren",
")",
"!=",
"-",
"1",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// Find any punctuation excluding the period final
|
[
"Find",
"any",
"punctuation",
"excluding",
"the",
"period",
"final"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/english/main.go#L77-L103
|
16,180 |
neurosnap/sentences
|
word_tokenizer.go
|
Tokenize
|
func (p *DefaultWordTokenizer) Tokenize(text string, onlyPeriodContext bool) []*Token {
textLength := len(text)
if textLength == 0 {
return nil
}
tokens := make([]*Token, 0, 50)
lastSpace := 0
lineStart := false
paragraphStart := false
getNextWord := false
for i, char := range text {
if !unicode.IsSpace(char) && i != textLength - 1 {
continue
}
if char == '\n' {
if lineStart {
paragraphStart = true
}
lineStart = true
}
var cursor int
if i == textLength - 1 {
cursor = textLength
} else {
cursor = i
}
word := strings.TrimSpace(text[lastSpace:cursor])
if word == "" {
continue
}
hasSentencePunct := p.PunctStrings.HasSentencePunct(word)
if onlyPeriodContext && !hasSentencePunct && !getNextWord {
lastSpace = cursor
continue
}
token := NewToken(word)
token.Position = cursor
token.ParaStart = paragraphStart
token.LineStart = lineStart
tokens = append(tokens, token)
lastSpace = cursor
lineStart = false
paragraphStart = false
if hasSentencePunct {
getNextWord = true
} else {
getNextWord = false
}
}
if len(tokens) == 0 {
token := NewToken(text)
token.Position = textLength
tokens = append(tokens, token)
}
return tokens
}
|
go
|
func (p *DefaultWordTokenizer) Tokenize(text string, onlyPeriodContext bool) []*Token {
textLength := len(text)
if textLength == 0 {
return nil
}
tokens := make([]*Token, 0, 50)
lastSpace := 0
lineStart := false
paragraphStart := false
getNextWord := false
for i, char := range text {
if !unicode.IsSpace(char) && i != textLength - 1 {
continue
}
if char == '\n' {
if lineStart {
paragraphStart = true
}
lineStart = true
}
var cursor int
if i == textLength - 1 {
cursor = textLength
} else {
cursor = i
}
word := strings.TrimSpace(text[lastSpace:cursor])
if word == "" {
continue
}
hasSentencePunct := p.PunctStrings.HasSentencePunct(word)
if onlyPeriodContext && !hasSentencePunct && !getNextWord {
lastSpace = cursor
continue
}
token := NewToken(word)
token.Position = cursor
token.ParaStart = paragraphStart
token.LineStart = lineStart
tokens = append(tokens, token)
lastSpace = cursor
lineStart = false
paragraphStart = false
if hasSentencePunct {
getNextWord = true
} else {
getNextWord = false
}
}
if len(tokens) == 0 {
token := NewToken(text)
token.Position = textLength
tokens = append(tokens, token)
}
return tokens
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"Tokenize",
"(",
"text",
"string",
",",
"onlyPeriodContext",
"bool",
")",
"[",
"]",
"*",
"Token",
"{",
"textLength",
":=",
"len",
"(",
"text",
")",
"\n\n",
"if",
"textLength",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"tokens",
":=",
"make",
"(",
"[",
"]",
"*",
"Token",
",",
"0",
",",
"50",
")",
"\n",
"lastSpace",
":=",
"0",
"\n",
"lineStart",
":=",
"false",
"\n",
"paragraphStart",
":=",
"false",
"\n",
"getNextWord",
":=",
"false",
"\n\n",
"for",
"i",
",",
"char",
":=",
"range",
"text",
"{",
"if",
"!",
"unicode",
".",
"IsSpace",
"(",
"char",
")",
"&&",
"i",
"!=",
"textLength",
"-",
"1",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"char",
"==",
"'\\n'",
"{",
"if",
"lineStart",
"{",
"paragraphStart",
"=",
"true",
"\n",
"}",
"\n",
"lineStart",
"=",
"true",
"\n",
"}",
"\n\n",
"var",
"cursor",
"int",
"\n",
"if",
"i",
"==",
"textLength",
"-",
"1",
"{",
"cursor",
"=",
"textLength",
"\n",
"}",
"else",
"{",
"cursor",
"=",
"i",
"\n",
"}",
"\n\n",
"word",
":=",
"strings",
".",
"TrimSpace",
"(",
"text",
"[",
"lastSpace",
":",
"cursor",
"]",
")",
"\n\n",
"if",
"word",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"hasSentencePunct",
":=",
"p",
".",
"PunctStrings",
".",
"HasSentencePunct",
"(",
"word",
")",
"\n",
"if",
"onlyPeriodContext",
"&&",
"!",
"hasSentencePunct",
"&&",
"!",
"getNextWord",
"{",
"lastSpace",
"=",
"cursor",
"\n",
"continue",
"\n",
"}",
"\n\n",
"token",
":=",
"NewToken",
"(",
"word",
")",
"\n",
"token",
".",
"Position",
"=",
"cursor",
"\n",
"token",
".",
"ParaStart",
"=",
"paragraphStart",
"\n",
"token",
".",
"LineStart",
"=",
"lineStart",
"\n",
"tokens",
"=",
"append",
"(",
"tokens",
",",
"token",
")",
"\n\n",
"lastSpace",
"=",
"cursor",
"\n",
"lineStart",
"=",
"false",
"\n",
"paragraphStart",
"=",
"false",
"\n\n",
"if",
"hasSentencePunct",
"{",
"getNextWord",
"=",
"true",
"\n",
"}",
"else",
"{",
"getNextWord",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"tokens",
")",
"==",
"0",
"{",
"token",
":=",
"NewToken",
"(",
"text",
")",
"\n",
"token",
".",
"Position",
"=",
"textLength",
"\n",
"tokens",
"=",
"append",
"(",
"tokens",
",",
"token",
")",
"\n",
"}",
"\n\n",
"return",
"tokens",
"\n",
"}"
] |
// Tokenize breaks text into words while preserving their character position, whether it starts
// a new line, and new paragraph.
|
[
"Tokenize",
"breaks",
"text",
"into",
"words",
"while",
"preserving",
"their",
"character",
"position",
"whether",
"it",
"starts",
"a",
"new",
"line",
"and",
"new",
"paragraph",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L69-L137
|
16,181 |
neurosnap/sentences
|
word_tokenizer.go
|
Type
|
func (p *DefaultWordTokenizer) Type(t *Token) string {
typ := t.reNumeric.ReplaceAllString(strings.ToLower(t.Tok), "##number##")
if len(typ) == 1 {
return typ
}
// removing comma from typ
return strings.Replace(typ, ",", "", -1)
}
|
go
|
func (p *DefaultWordTokenizer) Type(t *Token) string {
typ := t.reNumeric.ReplaceAllString(strings.ToLower(t.Tok), "##number##")
if len(typ) == 1 {
return typ
}
// removing comma from typ
return strings.Replace(typ, ",", "", -1)
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"Type",
"(",
"t",
"*",
"Token",
")",
"string",
"{",
"typ",
":=",
"t",
".",
"reNumeric",
".",
"ReplaceAllString",
"(",
"strings",
".",
"ToLower",
"(",
"t",
".",
"Tok",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"typ",
")",
"==",
"1",
"{",
"return",
"typ",
"\n",
"}",
"\n\n",
"// removing comma from typ",
"return",
"strings",
".",
"Replace",
"(",
"typ",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"}"
] |
// Type returns a case-normalized representation of the token.
|
[
"Type",
"returns",
"a",
"case",
"-",
"normalized",
"representation",
"of",
"the",
"token",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L140-L148
|
16,182 |
neurosnap/sentences
|
word_tokenizer.go
|
TypeNoPeriod
|
func (p *DefaultWordTokenizer) TypeNoPeriod(t *Token) string {
typ := p.Type(t)
if len(typ) > 1 && string(typ[len(typ)-1]) == "." {
return string(typ[:len(typ)-1])
}
return typ
}
|
go
|
func (p *DefaultWordTokenizer) TypeNoPeriod(t *Token) string {
typ := p.Type(t)
if len(typ) > 1 && string(typ[len(typ)-1]) == "." {
return string(typ[:len(typ)-1])
}
return typ
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"TypeNoPeriod",
"(",
"t",
"*",
"Token",
")",
"string",
"{",
"typ",
":=",
"p",
".",
"Type",
"(",
"t",
")",
"\n",
"if",
"len",
"(",
"typ",
")",
">",
"1",
"&&",
"string",
"(",
"typ",
"[",
"len",
"(",
"typ",
")",
"-",
"1",
"]",
")",
"==",
"\"",
"\"",
"{",
"return",
"string",
"(",
"typ",
"[",
":",
"len",
"(",
"typ",
")",
"-",
"1",
"]",
")",
"\n",
"}",
"\n",
"return",
"typ",
"\n",
"}"
] |
// TypeNoPeriod is the type with its final period removed if it has one.
|
[
"TypeNoPeriod",
"is",
"the",
"type",
"with",
"its",
"final",
"period",
"removed",
"if",
"it",
"has",
"one",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L151-L157
|
16,183 |
neurosnap/sentences
|
word_tokenizer.go
|
TypeNoSentPeriod
|
func (p *DefaultWordTokenizer) TypeNoSentPeriod(t *Token) string {
if p == nil {
return ""
}
if t.SentBreak {
return p.TypeNoPeriod(t)
}
return p.Type(t)
}
|
go
|
func (p *DefaultWordTokenizer) TypeNoSentPeriod(t *Token) string {
if p == nil {
return ""
}
if t.SentBreak {
return p.TypeNoPeriod(t)
}
return p.Type(t)
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"TypeNoSentPeriod",
"(",
"t",
"*",
"Token",
")",
"string",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"t",
".",
"SentBreak",
"{",
"return",
"p",
".",
"TypeNoPeriod",
"(",
"t",
")",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"Type",
"(",
"t",
")",
"\n",
"}"
] |
// TypeNoSentPeriod is the type with its final period removed if it is marked as a sentence break.
|
[
"TypeNoSentPeriod",
"is",
"the",
"type",
"with",
"its",
"final",
"period",
"removed",
"if",
"it",
"is",
"marked",
"as",
"a",
"sentence",
"break",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L160-L170
|
16,184 |
neurosnap/sentences
|
word_tokenizer.go
|
FirstUpper
|
func (p *DefaultWordTokenizer) FirstUpper(t *Token) bool {
if t.Tok == "" {
return false
}
runes := []rune(t.Tok)
return unicode.IsUpper(runes[0])
}
|
go
|
func (p *DefaultWordTokenizer) FirstUpper(t *Token) bool {
if t.Tok == "" {
return false
}
runes := []rune(t.Tok)
return unicode.IsUpper(runes[0])
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"FirstUpper",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"if",
"t",
".",
"Tok",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"runes",
":=",
"[",
"]",
"rune",
"(",
"t",
".",
"Tok",
")",
"\n",
"return",
"unicode",
".",
"IsUpper",
"(",
"runes",
"[",
"0",
"]",
")",
"\n",
"}"
] |
// FirstUpper is true if the token's first character is uppercase.
|
[
"FirstUpper",
"is",
"true",
"if",
"the",
"token",
"s",
"first",
"character",
"is",
"uppercase",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L173-L180
|
16,185 |
neurosnap/sentences
|
word_tokenizer.go
|
FirstLower
|
func (p *DefaultWordTokenizer) FirstLower(t *Token) bool {
if t.Tok == "" {
return false
}
runes := []rune(t.Tok)
return unicode.IsLower(runes[0])
}
|
go
|
func (p *DefaultWordTokenizer) FirstLower(t *Token) bool {
if t.Tok == "" {
return false
}
runes := []rune(t.Tok)
return unicode.IsLower(runes[0])
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"FirstLower",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"if",
"t",
".",
"Tok",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"runes",
":=",
"[",
"]",
"rune",
"(",
"t",
".",
"Tok",
")",
"\n",
"return",
"unicode",
".",
"IsLower",
"(",
"runes",
"[",
"0",
"]",
")",
"\n",
"}"
] |
// FirstLower is true if the token's first character is lowercase
|
[
"FirstLower",
"is",
"true",
"if",
"the",
"token",
"s",
"first",
"character",
"is",
"lowercase"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L183-L190
|
16,186 |
neurosnap/sentences
|
word_tokenizer.go
|
IsEllipsis
|
func (p *DefaultWordTokenizer) IsEllipsis(t *Token) bool {
return t.reEllipsis.MatchString(t.Tok)
}
|
go
|
func (p *DefaultWordTokenizer) IsEllipsis(t *Token) bool {
return t.reEllipsis.MatchString(t.Tok)
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"IsEllipsis",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"return",
"t",
".",
"reEllipsis",
".",
"MatchString",
"(",
"t",
".",
"Tok",
")",
"\n",
"}"
] |
// IsEllipsis is true if the token text is that of an ellipsis.
|
[
"IsEllipsis",
"is",
"true",
"if",
"the",
"token",
"text",
"is",
"that",
"of",
"an",
"ellipsis",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L193-L195
|
16,187 |
neurosnap/sentences
|
word_tokenizer.go
|
IsNumber
|
func (p *DefaultWordTokenizer) IsNumber(t *Token) bool {
return strings.HasPrefix(t.Tok, "##number##")
}
|
go
|
func (p *DefaultWordTokenizer) IsNumber(t *Token) bool {
return strings.HasPrefix(t.Tok, "##number##")
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"IsNumber",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"return",
"strings",
".",
"HasPrefix",
"(",
"t",
".",
"Tok",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// IsNumber is true if the token text is that of a number.
|
[
"IsNumber",
"is",
"true",
"if",
"the",
"token",
"text",
"is",
"that",
"of",
"a",
"number",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L198-L200
|
16,188 |
neurosnap/sentences
|
word_tokenizer.go
|
IsInitial
|
func (p *DefaultWordTokenizer) IsInitial(t *Token) bool {
return t.reInitial.MatchString(t.Tok)
}
|
go
|
func (p *DefaultWordTokenizer) IsInitial(t *Token) bool {
return t.reInitial.MatchString(t.Tok)
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"IsInitial",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"return",
"t",
".",
"reInitial",
".",
"MatchString",
"(",
"t",
".",
"Tok",
")",
"\n",
"}"
] |
// IsInitial is true if the token text is that of an initial.
|
[
"IsInitial",
"is",
"true",
"if",
"the",
"token",
"text",
"is",
"that",
"of",
"an",
"initial",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L203-L205
|
16,189 |
neurosnap/sentences
|
word_tokenizer.go
|
IsAlpha
|
func (p *DefaultWordTokenizer) IsAlpha(t *Token) bool {
return t.reAlpha.MatchString(t.Tok)
}
|
go
|
func (p *DefaultWordTokenizer) IsAlpha(t *Token) bool {
return t.reAlpha.MatchString(t.Tok)
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"IsAlpha",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"return",
"t",
".",
"reAlpha",
".",
"MatchString",
"(",
"t",
".",
"Tok",
")",
"\n",
"}"
] |
// IsAlpha is true if the token text is all alphabetic.
|
[
"IsAlpha",
"is",
"true",
"if",
"the",
"token",
"text",
"is",
"all",
"alphabetic",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L208-L210
|
16,190 |
neurosnap/sentences
|
word_tokenizer.go
|
IsNonPunct
|
func (p *DefaultWordTokenizer) IsNonPunct(t *Token) bool {
nonPunct := regexp.MustCompile(p.PunctStrings.NonPunct())
return nonPunct.MatchString(p.Type(t))
}
|
go
|
func (p *DefaultWordTokenizer) IsNonPunct(t *Token) bool {
nonPunct := regexp.MustCompile(p.PunctStrings.NonPunct())
return nonPunct.MatchString(p.Type(t))
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"IsNonPunct",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"nonPunct",
":=",
"regexp",
".",
"MustCompile",
"(",
"p",
".",
"PunctStrings",
".",
"NonPunct",
"(",
")",
")",
"\n",
"return",
"nonPunct",
".",
"MatchString",
"(",
"p",
".",
"Type",
"(",
"t",
")",
")",
"\n",
"}"
] |
// IsNonPunct is true if the token is either a number or is alphabetic.
|
[
"IsNonPunct",
"is",
"true",
"if",
"the",
"token",
"is",
"either",
"a",
"number",
"or",
"is",
"alphabetic",
"."
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L213-L216
|
16,191 |
neurosnap/sentences
|
word_tokenizer.go
|
HasPeriodFinal
|
func (p *DefaultWordTokenizer) HasPeriodFinal(t *Token) bool {
return strings.HasSuffix(t.Tok, ".")
}
|
go
|
func (p *DefaultWordTokenizer) HasPeriodFinal(t *Token) bool {
return strings.HasSuffix(t.Tok, ".")
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"HasPeriodFinal",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"return",
"strings",
".",
"HasSuffix",
"(",
"t",
".",
"Tok",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// HasPeriodFinal is true if the last character in the word is a period
|
[
"HasPeriodFinal",
"is",
"true",
"if",
"the",
"last",
"character",
"in",
"the",
"word",
"is",
"a",
"period"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L219-L221
|
16,192 |
neurosnap/sentences
|
word_tokenizer.go
|
HasSentEndChars
|
func (p *DefaultWordTokenizer) HasSentEndChars(t *Token) bool {
enders := []string{
`."`, `.'`, `.)`,
`?`, `?"`, `?'`, `?)`,
`!`, `!"`, `!'`, `!)`, `!’`, `!”`,
}
for _, ender := range enders {
if strings.HasSuffix(t.Tok, ender) {
return true
}
}
parens := []string{
`.[`, `.(`, `."`, `.'`,
`?[`, `?(`,
`![`, `!(`,
}
for _, paren := range parens {
if strings.Index(t.Tok, paren) != -1 {
return true
}
}
return false
}
|
go
|
func (p *DefaultWordTokenizer) HasSentEndChars(t *Token) bool {
enders := []string{
`."`, `.'`, `.)`,
`?`, `?"`, `?'`, `?)`,
`!`, `!"`, `!'`, `!)`, `!’`, `!”`,
}
for _, ender := range enders {
if strings.HasSuffix(t.Tok, ender) {
return true
}
}
parens := []string{
`.[`, `.(`, `."`, `.'`,
`?[`, `?(`,
`![`, `!(`,
}
for _, paren := range parens {
if strings.Index(t.Tok, paren) != -1 {
return true
}
}
return false
}
|
[
"func",
"(",
"p",
"*",
"DefaultWordTokenizer",
")",
"HasSentEndChars",
"(",
"t",
"*",
"Token",
")",
"bool",
"{",
"enders",
":=",
"[",
"]",
"string",
"{",
"`.\"`",
",",
"`.'`",
",",
"`.)`",
",",
"`?`",
",",
"`?\"`",
",",
"`?'`",
",",
"`?)`",
",",
"`!`",
",",
"`!\"`",
",",
"`!'`",
",",
"`!)`",
",",
"`!’`, ",
"`",
"”`,",
"",
"}",
"\n\n",
"for",
"_",
",",
"ender",
":=",
"range",
"enders",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"t",
".",
"Tok",
",",
"ender",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"parens",
":=",
"[",
"]",
"string",
"{",
"`.[`",
",",
"`.(`",
",",
"`.\"`",
",",
"`.'`",
",",
"`?[`",
",",
"`?(`",
",",
"`![`",
",",
"`!(`",
",",
"}",
"\n\n",
"for",
"_",
",",
"paren",
":=",
"range",
"parens",
"{",
"if",
"strings",
".",
"Index",
"(",
"t",
".",
"Tok",
",",
"paren",
")",
"!=",
"-",
"1",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// HasSentEndChars finds any punctuation excluding the period final
|
[
"HasSentEndChars",
"finds",
"any",
"punctuation",
"excluding",
"the",
"period",
"final"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/word_tokenizer.go#L224-L250
|
16,193 |
neurosnap/sentences
|
storage.go
|
Has
|
func (ss SetString) Has(str string) bool {
if ss[str] == 0 {
return false
}
return true
}
|
go
|
func (ss SetString) Has(str string) bool {
if ss[str] == 0 {
return false
}
return true
}
|
[
"func",
"(",
"ss",
"SetString",
")",
"Has",
"(",
"str",
"string",
")",
"bool",
"{",
"if",
"ss",
"[",
"str",
"]",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Has checks whether a key exists in the set
|
[
"Has",
"checks",
"whether",
"a",
"key",
"exists",
"in",
"the",
"set"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/storage.go#L20-L26
|
16,194 |
neurosnap/sentences
|
storage.go
|
Array
|
func (ss SetString) Array() []string {
arr := make([]string, 0, len(ss))
for key := range ss {
arr = append(arr, key)
}
return arr
}
|
go
|
func (ss SetString) Array() []string {
arr := make([]string, 0, len(ss))
for key := range ss {
arr = append(arr, key)
}
return arr
}
|
[
"func",
"(",
"ss",
"SetString",
")",
"Array",
"(",
")",
"[",
"]",
"string",
"{",
"arr",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"ss",
")",
")",
"\n\n",
"for",
"key",
":=",
"range",
"ss",
"{",
"arr",
"=",
"append",
"(",
"arr",
",",
"key",
")",
"\n",
"}",
"\n\n",
"return",
"arr",
"\n",
"}"
] |
// Array returns and array of keys from the set
|
[
"Array",
"returns",
"and",
"array",
"of",
"keys",
"from",
"the",
"set"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/storage.go#L29-L37
|
16,195 |
neurosnap/sentences
|
storage.go
|
addOrthoContext
|
func (p *Storage) addOrthoContext(typ string, flag int) {
p.OrthoContext[typ] |= flag
}
|
go
|
func (p *Storage) addOrthoContext(typ string, flag int) {
p.OrthoContext[typ] |= flag
}
|
[
"func",
"(",
"p",
"*",
"Storage",
")",
"addOrthoContext",
"(",
"typ",
"string",
",",
"flag",
"int",
")",
"{",
"p",
".",
"OrthoContext",
"[",
"typ",
"]",
"|=",
"flag",
"\n",
"}"
] |
// Used in the training to add a type to the ortho context
|
[
"Used",
"in",
"the",
"training",
"to",
"add",
"a",
"type",
"to",
"the",
"ortho",
"context"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/storage.go#L68-L70
|
16,196 |
neurosnap/sentences
|
storage.go
|
IsAbbr
|
func (p *Storage) IsAbbr(tokens ...string) bool {
for _, token := range tokens {
if p.AbbrevTypes.Has(token) {
return true
}
}
return false
}
|
go
|
func (p *Storage) IsAbbr(tokens ...string) bool {
for _, token := range tokens {
if p.AbbrevTypes.Has(token) {
return true
}
}
return false
}
|
[
"func",
"(",
"p",
"*",
"Storage",
")",
"IsAbbr",
"(",
"tokens",
"...",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"token",
":=",
"range",
"tokens",
"{",
"if",
"p",
".",
"AbbrevTypes",
".",
"Has",
"(",
"token",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// IsAbbr detemines if any of the tokens are an abbreviation
|
[
"IsAbbr",
"detemines",
"if",
"any",
"of",
"the",
"tokens",
"are",
"an",
"abbreviation"
] |
3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738
|
https://github.com/neurosnap/sentences/blob/3b15ce5436aa9cad8fa2a13afd8a7b9c0d8b9738/storage.go#L73-L81
|
16,197 |
coocood/qbs
|
model.go
|
Add
|
func (ix *Indexes) Add(columns ...string) {
name := strings.Join(columns, "_")
*ix = append(*ix, &index{name: name, columns: columns, unique: false})
}
|
go
|
func (ix *Indexes) Add(columns ...string) {
name := strings.Join(columns, "_")
*ix = append(*ix, &index{name: name, columns: columns, unique: false})
}
|
[
"func",
"(",
"ix",
"*",
"Indexes",
")",
"Add",
"(",
"columns",
"...",
"string",
")",
"{",
"name",
":=",
"strings",
".",
"Join",
"(",
"columns",
",",
"\"",
"\"",
")",
"\n",
"*",
"ix",
"=",
"append",
"(",
"*",
"ix",
",",
"&",
"index",
"{",
"name",
":",
"name",
",",
"columns",
":",
"columns",
",",
"unique",
":",
"false",
"}",
")",
"\n",
"}"
] |
// Add adds an index
|
[
"Add",
"adds",
"an",
"index"
] |
8554e18a96c91918e49c8cb375ece4876e69c1f0
|
https://github.com/coocood/qbs/blob/8554e18a96c91918e49c8cb375ece4876e69c1f0/model.go#L50-L53
|
16,198 |
coocood/qbs
|
model.go
|
AddUnique
|
func (ix *Indexes) AddUnique(columns ...string) {
name := strings.Join(columns, "_")
*ix = append(*ix, &index{name: name, columns: columns, unique: true})
}
|
go
|
func (ix *Indexes) AddUnique(columns ...string) {
name := strings.Join(columns, "_")
*ix = append(*ix, &index{name: name, columns: columns, unique: true})
}
|
[
"func",
"(",
"ix",
"*",
"Indexes",
")",
"AddUnique",
"(",
"columns",
"...",
"string",
")",
"{",
"name",
":=",
"strings",
".",
"Join",
"(",
"columns",
",",
"\"",
"\"",
")",
"\n",
"*",
"ix",
"=",
"append",
"(",
"*",
"ix",
",",
"&",
"index",
"{",
"name",
":",
"name",
",",
"columns",
":",
"columns",
",",
"unique",
":",
"true",
"}",
")",
"\n",
"}"
] |
// AddUnique adds an unique index
|
[
"AddUnique",
"adds",
"an",
"unique",
"index"
] |
8554e18a96c91918e49c8cb375ece4876e69c1f0
|
https://github.com/coocood/qbs/blob/8554e18a96c91918e49c8cb375ece4876e69c1f0/model.go#L56-L59
|
16,199 |
coocood/qbs
|
migration.go
|
CreateTableIfNotExists
|
func (mg *Migration) CreateTableIfNotExists(structPtr interface{}) error {
model := structPtrToModel(structPtr, true, nil)
sql := mg.dialect.createTableSql(model, true)
if mg.Log {
fmt.Println(sql)
}
sqls := strings.Split(sql, ";")
for _, v := range sqls {
_, err := mg.db.Exec(v)
if err != nil && !mg.dialect.catchMigrationError(err) {
panic(err)
}
}
columns := mg.dialect.columnsInTable(mg, model.table)
if len(model.fields) > len(columns) {
oldFields := []*modelField{}
newFields := []*modelField{}
for _, v := range model.fields {
if _, ok := columns[v.name]; ok {
oldFields = append(oldFields, v)
} else {
newFields = append(newFields, v)
}
}
if len(oldFields) != len(columns) {
panic("Column name has changed, rename column migration is not supported.")
}
for _, v := range newFields {
mg.addColumn(model.table, v)
}
}
var indexErr error
for _, i := range model.indexes {
indexErr = mg.CreateIndexIfNotExists(model.table, i.name, i.unique, i.columns...)
}
return indexErr
}
|
go
|
func (mg *Migration) CreateTableIfNotExists(structPtr interface{}) error {
model := structPtrToModel(structPtr, true, nil)
sql := mg.dialect.createTableSql(model, true)
if mg.Log {
fmt.Println(sql)
}
sqls := strings.Split(sql, ";")
for _, v := range sqls {
_, err := mg.db.Exec(v)
if err != nil && !mg.dialect.catchMigrationError(err) {
panic(err)
}
}
columns := mg.dialect.columnsInTable(mg, model.table)
if len(model.fields) > len(columns) {
oldFields := []*modelField{}
newFields := []*modelField{}
for _, v := range model.fields {
if _, ok := columns[v.name]; ok {
oldFields = append(oldFields, v)
} else {
newFields = append(newFields, v)
}
}
if len(oldFields) != len(columns) {
panic("Column name has changed, rename column migration is not supported.")
}
for _, v := range newFields {
mg.addColumn(model.table, v)
}
}
var indexErr error
for _, i := range model.indexes {
indexErr = mg.CreateIndexIfNotExists(model.table, i.name, i.unique, i.columns...)
}
return indexErr
}
|
[
"func",
"(",
"mg",
"*",
"Migration",
")",
"CreateTableIfNotExists",
"(",
"structPtr",
"interface",
"{",
"}",
")",
"error",
"{",
"model",
":=",
"structPtrToModel",
"(",
"structPtr",
",",
"true",
",",
"nil",
")",
"\n",
"sql",
":=",
"mg",
".",
"dialect",
".",
"createTableSql",
"(",
"model",
",",
"true",
")",
"\n",
"if",
"mg",
".",
"Log",
"{",
"fmt",
".",
"Println",
"(",
"sql",
")",
"\n",
"}",
"\n",
"sqls",
":=",
"strings",
".",
"Split",
"(",
"sql",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"sqls",
"{",
"_",
",",
"err",
":=",
"mg",
".",
"db",
".",
"Exec",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"mg",
".",
"dialect",
".",
"catchMigrationError",
"(",
"err",
")",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"columns",
":=",
"mg",
".",
"dialect",
".",
"columnsInTable",
"(",
"mg",
",",
"model",
".",
"table",
")",
"\n",
"if",
"len",
"(",
"model",
".",
"fields",
")",
">",
"len",
"(",
"columns",
")",
"{",
"oldFields",
":=",
"[",
"]",
"*",
"modelField",
"{",
"}",
"\n",
"newFields",
":=",
"[",
"]",
"*",
"modelField",
"{",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"model",
".",
"fields",
"{",
"if",
"_",
",",
"ok",
":=",
"columns",
"[",
"v",
".",
"name",
"]",
";",
"ok",
"{",
"oldFields",
"=",
"append",
"(",
"oldFields",
",",
"v",
")",
"\n",
"}",
"else",
"{",
"newFields",
"=",
"append",
"(",
"newFields",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"oldFields",
")",
"!=",
"len",
"(",
"columns",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"newFields",
"{",
"mg",
".",
"addColumn",
"(",
"model",
".",
"table",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"indexErr",
"error",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"model",
".",
"indexes",
"{",
"indexErr",
"=",
"mg",
".",
"CreateIndexIfNotExists",
"(",
"model",
".",
"table",
",",
"i",
".",
"name",
",",
"i",
".",
"unique",
",",
"i",
".",
"columns",
"...",
")",
"\n",
"}",
"\n",
"return",
"indexErr",
"\n",
"}"
] |
// CreateTableIfNotExists creates a new table and its indexes based on the table struct type
// It will panic if table creation failed, and it will return error if the index creation failed.
|
[
"CreateTableIfNotExists",
"creates",
"a",
"new",
"table",
"and",
"its",
"indexes",
"based",
"on",
"the",
"table",
"struct",
"type",
"It",
"will",
"panic",
"if",
"table",
"creation",
"failed",
"and",
"it",
"will",
"return",
"error",
"if",
"the",
"index",
"creation",
"failed",
"."
] |
8554e18a96c91918e49c8cb375ece4876e69c1f0
|
https://github.com/coocood/qbs/blob/8554e18a96c91918e49c8cb375ece4876e69c1f0/migration.go#L18-L54
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.