id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c175600 |
helpers := template.FuncMap{}
t := gogen.TemplateTransformer(data, helpers)
g.Transformer(t)
g.Box(packr.New("buffalo:genny:newapp:api", "../api/templates"))
gg.Add(g)
return gg, nil
} | |
c175601 | a.ErrorHandlers.Get(code)(code, err, c)
}
}
a.router.NotFoundHandler = notFoundHandler("path not found: %s %s", 404)
a.router.MethodNotAllowedHandler = notFoundHandler("method not found: %s %s", 405)
if a.MethodOverride == nil {
a.MethodOverride = MethodOverride
}
a.Use(a.PanicHandler)
a.Use(RequestLogger)
a.Use(sessionSaver)
return a
} | |
c175602 |
if bytes.Contains(b, []byte("T.CookieName")) {
b = bytes.Replace(b, []byte("T.CookieName"), []byte("T.LanguageExtractorOptions[\"CookieName\"]"), -1)
}
if bytes.Contains(b, []byte("T.SessionName")) {
b = bytes.Replace(b, []byte("T.SessionName"), []byte("T.LanguageExtractorOptions[\"SessionName\"]"), -1)
}
if bytes.Contains(b, []byte("T.LanguageFinder=")) || bytes.Contains(b, []byte("T.LanguageFinder ")) {
r.Warnings = append(r.Warnings, fmt.Sprintf("i18n.Translator#LanguageFinder has been deprecated in v0.11.1, and has been removed in v0.12.0. Use i18n.Translator#LanguageExtractors instead. [%s]", path))
}
ioutil.WriteFile(path, b, 0664)
return nil
})
} | |
c175603 | errors.New("resource not implemented"))
} | |
c175604 |
return s.renderFunc(w, data)
} | |
c175605 | {
return s.Session.Save(s.req, s.res)
} | |
c175606 | s.Delete(name)
return x
}
return nil
} | |
c175607 | interface{}) {
s.Session.Values[name] = value
} | |
c175608 | k := range s.Session.Values {
s.Delete(k)
}
} | |
c175609 | a.SessionName)
return &Session{
Session: session,
req: r,
res: w,
}
} | |
c175610 | := gogen.TemplateTransformer(data, template.FuncMap{})
g.Transformer(t)
g.RunFn(func(r *genny.Runner) error {
return genFile(r, opts)
})
return g, nil
} | |
c175611 | find npm executable")
}
return nil
})
g.Box(Templates)
data := map[string]interface{}{
"opts": opts,
}
t := gogen.TemplateTransformer(data, gogen.TemplateHelpers)
g.Transformer(t)
g.Transformer(genny.Dot())
g.RunFn(func(r *genny.Runner) error {
return installPkgs(r, opts)
})
return g, nil
} | |
c175612 | "../refresh/templates"))
ctx := plush.NewContext()
ctx.Set("app", opts.App)
g.Transformer(plushgen.Transformer(ctx))
g.Transformer(genny.Dot())
return g, nil
} | |
c175613 |
if m.encoding == Base64 {
m.hEncoder = bEncoding
} else {
m.hEncoder = qEncoding
}
return m
} | |
c175614 | nil
m.attachments = nil
m.embedded = nil
} | |
c175615 | ...string) {
m.encodeHeader(value)
m.header[field] = value
} | |
c175616 | {
for k, v := range h {
m.SetHeader(k, v...)
}
} | |
c175617 | m.header[field] = []string{m.FormatAddress(address, name)}
} | |
c175618 | == '"' {
m.buf.WriteByte('\\')
}
m.buf.WriteByte(b)
}
m.buf.WriteByte('"')
} else if hasSpecials(name) {
m.buf.WriteString(bEncoding.Encode(m.charset, name))
} else {
m.buf.WriteString(enc)
}
m.buf.WriteString(" <")
m.buf.WriteString(address)
m.buf.WriteByte('>')
addr := m.buf.String()
m.buf.Reset()
return addr
} | |
c175619 | m.header[field] = []string{m.FormatDate(date)}
} | |
c175620 | date.Format(time.RFC1123Z)
} | |
c175621 | ...PartSetting) {
m.SetBodyWriter(contentType, newCopier(body), settings...)
} | |
c175622 | *part) {
p.encoding = e
})
} | |
c175623 | v := range h {
f.Header[k] = v
}
}
} | |
c175624 | func(fi *file) {
fi.CopyFunc = f
}
} | |
c175625 | m.appendFile(m.attachments, fileFromReader(name, r), settings)
} | |
c175626 | m.appendFile(m.attachments, fileFromFilename(filename), settings)
} | |
c175627 | = m.appendFile(m.embedded, fileFromReader(name, r), settings)
} | |
c175628 | m.appendFile(m.embedded, fileFromFilename(filename), settings)
} | |
c175629 |
errs = append(errs, fmt.Sprintf("template error in file %s: %s", path, err.Error()))
}
})
if err != nil {
return err
}
}
return nil
})
if err != nil {
return err
}
if len(errs) == 0 {
return nil
}
return errors.New(strings.Join(errs, "\n"))
}
} | |
c175630 | }
_, err := plush.Parse(f.String())
return err
} | |
c175631 |
return errors.New("you must supply a name for your mailer")
}
return nil
} | |
c175632 | cmd := exec.Command(c.Binary, c.UseCommand, string(b))
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
cmd.Stdin = os.Stdin
if err := cmd.Run(); err != nil {
fmt.Println("error trying to send event", strings.Join(cmd.Args, " "), err)
}
}
_, err := events.NamedListen(n, events.Filter(c.ListenFor, fn))
if err != nil {
return err
}
return nil
})
}(c)
if err != nil {
err = err
return
}
}
}
})
return err
} | |
c175633 | i
w.ResponseWriter.WriteHeader(i)
} | |
c175634 | binary.Size(b)
return w.ResponseWriter.Write(b)
} | |
c175635 | := w.ResponseWriter.(http.Flusher); ok {
f.Flush()
}
} | |
c175636 |
return cn.CloseNotify()
}
return nil
} | |
c175637 | !!!\n\n", len(r.Warnings))
for _, w := range r.Warnings {
fmt.Printf("[WARNING]: %s\n", w)
}
}()
for _, c := range checks {
if err := c(r); err != nil {
return err
}
}
return nil
} | |
c175638 | "node_modules", ".git"} {
if base == n {
return filepath.SkipDir
}
}
return nil
}
ext := filepath.Ext(p)
if ext != ".go" {
return nil
}
return fn(p)
} | |
c175639 | = map[string]interface{}{}
t := template.New(input)
if helpers != nil {
t = t.Funcs(helpers)
}
t, err := t.Parse(input)
if err != nil {
return "", err
}
bb := &bytes.Buffer{}
err = t.Execute(bb, data)
return bb.String(), err
} | |
c175640 | a.addRoute("GET", p, h)
} | |
c175641 | func(c Context) error {
return c.Redirect(status, to)
})
} | |
c175642 | h)
a.PUT(p, h)
a.PATCH(p, h)
a.HEAD(p, h)
a.OPTIONS(p, h)
a.DELETE(p, h)
} | |
c175643 | continue
}
if index > 0 && strings.Contains(parts[index-1], "}") {
resultParts = append(resultParts, part)
continue
}
resultParts = append(resultParts, part)
}
if len(resultParts) == 0 {
return "unnamed"
}
underscore := strings.TrimSpace(strings.Join(resultParts, "_"))
return name.VarCase(underscore)
} | |
c175644 |
g := genny.New()
h := template.FuncMap{}
data := map[string]interface{}{
"opts": opts,
}
t := gogen.TemplateTransformer(data, h)
g.Transformer(t)
fn := opts.Name.File().String()
g.File(genny.NewFileS("mailers/"+fn+".go.tmpl", mailerTmpl))
g.File(genny.NewFileS("templates/mail/"+fn+".html.tmpl", mailTmpl))
gg.Add(g)
return gg, nil
} | |
c175645 | username,
Password: password,
SSL: port == 465,
Timeout: 10 * time.Second,
RetryFailure: true,
}
} | |
c175646 |
if ok, auths := c.Extension("AUTH"); ok {
if strings.Contains(auths, "CRAM-MD5") {
d.Auth = smtp.CRAMMD5Auth(d.Username, d.Password)
} else if strings.Contains(auths, "LOGIN") &&
!strings.Contains(auths, "PLAIN") {
d.Auth = &loginAuth{
username: d.Username,
password: d.Password,
host: d.Host,
}
} else {
d.Auth = smtp.PlainAuth("", d.Username, d.Password, d.Host)
}
}
}
if d.Auth != nil {
if err = c.Auth(d.Auth); err != nil {
c.Close()
return nil, err
}
}
return &smtpSender{c, conn, d}, nil
} | |
c175647 | return err
}
defer s.Close()
return Send(s, m...)
} | |
c175648 | f.data[key] = values
} | |
c175649 | return
}
f.data[key] = append(f.data[key], value)
} | |
c175650 | session.Set(flashKey, b)
session.Save()
} | |
c175651 | f := session.Get(flashKey); f != nil {
json.Unmarshal(f.([]byte), &result.data)
}
}
return result
} | |
c175652 | return "", err
}
return ck.Value, nil
} | |
c175653 | value,
MaxAge: int(maxAge.Seconds()),
}
http.SetCookie(c.res, &ck)
} | |
c175654 |
ck := http.Cookie{
Name: name,
Value: value,
Expires: expires,
}
http.SetCookie(c.res, &ck)
} | |
c175655 | the distant past, like the unix epoch, removes the cookie,
// since it has long expired.
Expires: time.Unix(0, 0),
}
http.SetCookie(c.res, &ck)
} | |
c175656 |
Headers: map[string]string{},
Data: render.Data{},
moot: &sync.RWMutex{},
}
} | |
c175657 | d[k] = v
}
m := NewMessage()
m.Data = d
return m
} | |
c175658 |
m := NewFromData(c.Data())
m.Context = c
return m
} | |
c175659 | cn, ok := es.w.(closeNotifier); ok {
return cn.CloseNotify()
}
return nil
} | |
c175660 |
es.w.Header().Set("Cache-Control", "no-cache")
es.w.Header().Set("Connection", "keep-alive")
es.w.Header().Set("Access-Control-Allow-Origin", "*")
return es, nil
} | |
c175661 | ctx,
cancel: cancel,
handlers: map[string]Handler{},
moot: &sync.Mutex{},
}
} | |
c175662 | return fmt.Errorf("handler already mapped for name %s", name)
}
w.handlers[name] = h
return nil
} | |
c175663 | w.ctx, w.cancel = context.WithCancel(ctx)
return nil
} | |
c175664 | Worker")
w.cancel()
return nil
} | |
c175665 | err != nil {
w.Logger.Error(err)
}
w.Logger.Debugf("Completed job %s", job)
}()
return nil
}
err := fmt.Errorf("no handler mapped for name %s", job.Handler)
w.Logger.Error(err)
return err
} | |
c175666 | w.PerformIn(job, time.Until(t))
} | |
c175667 | w.Perform(job)
case <-w.ctx.Done():
w.cancel()
}
}()
return nil
} | |
c175668 | _ := json.MarshalIndent(ri, "", " ")
return string(b)
} | |
c175669 |
ri.App.router.Handle(a, ri).Methods(ri.Method)
}
return ri
} | |
c175670 |
break
}
}
name = flect.Camelize(name)
if !strings.HasSuffix(name, "Path") {
name = name + "Path"
}
ri.PathName = name
if routeIndex != -1 {
ri.App.Routes()[routeIndex] = reflect.ValueOf(ri).Interface().(*RouteInfo)
}
return ri
} | |
c175671 | pairs = append(pairs, fmt.Sprintf("%v", v))
}
url, err := cRoute.MuxRoute.URL(pairs...)
if err != nil {
return "", errors.Wrapf(err, "missing parameters for %v", cRoute.Path)
}
result := url.Path
result = addExtraParamsTo(result, opts)
return template.HTML(result), nil
}
} | |
c175672 | default:
return g, fmt.Errorf("could not find a template for %s", opts.Provider)
}
f, err := box.FindString(fname)
if err != nil {
return g, err
}
g.File(genny.NewFileS(fname, f))
data := map[string]interface{}{
"opts": opts,
}
if opts.DBType == "postgres" {
data["testDbUrl"] = "postgres://postgres:postgres@postgres:5432/" + opts.App.Name.File().String() + "_test?sslmode=disable"
} else if opts.DBType == "mysql" {
data["testDbUrl"] = "mysql://root:root@(mysql:3306)/" + opts.App.Name.File().String() + "_test?parseTime=true&multiStatements=true&readTimeout=1s"
} else {
data["testDbUrl"] = ""
}
helpers := template.FuncMap{}
t := gogen.TemplateTransformer(data, helpers)
g.Transformer(t)
return g, nil
} | |
c175673 | {
return g, err
}
g.RunFn(construct(opts))
return g, nil
} | |
c175674 | (func([]string) (interface{}, error))(fn)
decoder.RegisterCustomType(rawFunc, types, fields)
} | |
c175675 | stack = append(stack, mw2)
} else {
stack = append(stack, mw)
}
}
ms.stack = stack
} | |
c175676 | return a.root.routes
}
return a.routes
} | |
c175677 | map it
// GET, POST, etc... we just need the underlying
// RouteInfo, which implements http.Handler
ri := a.GET("/", h)
return ri
} | |
c175678 | err
}
_, err = pf.Write(bb.Bytes())
if err != nil {
return err
}
err = pf.Close()
if err != nil {
return err
}
os.RemoveAll(filepath.Join(r.App.Root, "node_modules"))
var cmd *exec.Cmd
if r.App.WithYarn {
cmd = exec.Command("yarnpkg", "install")
} else {
cmd = exec.Command("npm", "install")
}
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
} | |
c175679 |
result := strings.Replace(importpath, key, value, 1)
return result, true
}
return importpath, false
} | |
c175680 | {
return &SendError{Cause: err, Index: uint(i)}
}
}
return nil
} | |
c175681 | {
return opts.Parts[len(opts.Parts)-1].String() == n.String()
} | |
c175682 | && errors.Cause(err) != context.Canceled {
a.Logger.Error(err)
return err
}
return nil
} | |
c175683 | }
if !r.App.WithDep {
fmt.Println("~~~ Running go get ~~~")
return modGetUpdate(r)
}
fmt.Println("~~~ Running dep ensure ~~~")
return runDepEnsure(r)
} | |
c175684 |
return fmt.Sprintf("%s (%s)", b.Version, b.Time)
} | |
c175685 |
Model: name.New(opts.Model),
Attrs: opts.Attrs,
}
x := pres.Name.Resource().File().String()
folder := pres.Name.Folder().Pluralize().String()
g.Transformer(genny.Replace("resource-name", x))
g.Transformer(genny.Replace("resource-use_model", x))
g.Transformer(genny.Replace("folder-name", folder))
data := map[string]interface{}{
"opts": pres,
"actions": actions(opts),
"folder": folder,
}
helpers := template.FuncMap{
"camelize": func(s string) string {
return flect.Camelize(s)
},
}
g.Transformer(gogen.TemplateTransformer(data, helpers))
g.RunFn(installPop(opts))
g.RunFn(addResource(pres))
return g, nil
} | |
c175686 | append(m.Bodies, Body{
Content: buf.String(),
ContentType: r.ContentType(),
})
return nil
} | |
c175687 |
err := m.AddBody(r, data)
if err != nil {
return err
}
}
return nil
} | |
c175688 | Attachment{
Name: name,
ContentType: contentType,
Reader: r,
Embedded: false,
})
return nil
} | |
c175689 | name,
Reader: r,
Embedded: true,
})
return nil
} | |
c175690 | m.Headers[field] = value
} | |
c175691 | t := gogen.TemplateTransformer(data, helpers)
g.Transformer(t)
g.Box(packr.New("buffalo:genny:newapp:web", "../web/templates"))
gg.Add(g)
if opts.Webpack != nil {
// add the webpack generator
g, err = webpack.New(opts.Webpack)
if err != nil {
return gg, err
}
gg.Add(g)
}
if opts.Standard != nil {
// add the standard generator
g, err = standard.New(opts.Standard)
if err != nil {
return gg, err
}
gg.Add(g)
}
return gg, nil
} | |
c175692 | if err != nil {
return err
}
s := strings.Replace(f.String(), "</title>", "</title>\n"+bs4, 1)
return r.File(genny.NewFileS(f.Name(), s))
})
return g, nil
} | |
c175693 | packr.Folder(filepath.Join(opts.App.Root, "config"))
g.RunFn(configs(opts, cBox))
aBox := packr.Folder(opts.App.Root)
g.RunFn(pkgChecks(opts, aBox))
return g, nil
} | |
c175694 |
})
if err != nil {
return err
}
for _, f := range r.Disk.Files() {
if err := r.Disk.Delete(f.Name()); err != nil {
return err
}
}
if envy.Mods() {
if err := r.Exec(exec.Command(genny.GoBin(), "mod", "tidy")); err != nil {
return err
}
}
return nil
}
} | |
c175695 |
}
source := github_flavored_markdown.Markdown([]byte(input))
source = []byte(html.UnescapeString(string(source)))
return plush.BuffaloRenderer(string(source), data, helpers)
} | |
c175696 | return fmt.Errorf("get file err: %v", err)
}
logger.WithFields(logrus.Fields{"key": upd.Key, "filename": upd.Filename}).Debug("Populating key.")
value := content
if upd.GZIP {
buff := bytes.NewBuffer([]byte{})
// TODO: this error is wildly unlikely for anything that
// would actually fit in a configmap, we could just as well return
// the error instead of falling back to the raw content
z := gzip.NewWriter(buff)
if _, err := z.Write(content); err != nil {
logger.WithError(err).Error("failed to gzip content, falling back to raw")
} else {
if err := z.Close(); err != nil {
logger.WithError(err).Error("failed to flush gzipped content (!?), falling back to raw")
} else {
value = buff.Bytes()
}
}
}
if utf8.ValidString(string(value)) {
delete(cm.BinaryData, upd.Key)
cm.Data[upd.Key] = string(value)
} else {
delete(cm.Data, upd.Key)
cm.BinaryData[upd.Key] = value
}
}
var updateErr error
var verb string
if getErr != nil && isNotFound {
verb = "create"
_, updateErr = kc.Create(cm)
} else {
verb = "update"
_, updateErr = kc.Update(cm)
}
if updateErr != nil {
return fmt.Errorf("%s config map err: %v", verb, updateErr)
}
return nil
} | |
c175697 | to remove the old key
if change.Status == github.PullRequestFileRenamed {
oldKey := path.Base(change.PreviousFilename)
// not setting the filename field will cause the key to be
// deleted
toUpdate[id] = append(toUpdate[id], ConfigMapUpdate{Key: oldKey})
}
}
if change.Status == github.PullRequestFileRemoved {
toUpdate[id] = append(toUpdate[id], ConfigMapUpdate{Key: key})
} else {
gzip := cfg.GZIP
if cm.GZIP != nil {
gzip = *cm.GZIP
}
toUpdate[id] = append(toUpdate[id], ConfigMapUpdate{Key: key, Filename: change.Filename, GZIP: gzip})
}
}
}
return toUpdate
} | |
c175698 | label = strings.ToLower(match[1] + "/" + strings.TrimSpace(label))
labels = append(labels, label)
}
}
return
} | |
c175699 | || len(parts) != 2 {
continue
}
for _, l := range additionalLabels {
if l == parts[1] {
labels = append(labels, parts[1])
}
}
}
return labels
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.