_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q175600 | New | test | func New(opts *Options) (*genny.Group, error) {
if err := opts.Validate(); err != nil {
return nil, err
}
gg, err := core.New(opts.Options)
if err != nil {
return gg, err
}
g := genny.New()
data := map[string]interface{}{
"opts": opts,
}
helpers := template.FuncMap{}
t := gogen.TemplateTransformer(d... | go | {
"resource": ""
} |
q175601 | New | test | func New(opts Options) *App {
LoadPlugins()
envy.Load()
opts = optionsWithDefaults(opts)
a := &App{
Options: opts,
ErrorHandlers: ErrorHandlers{
404: defaultErrorHandler,
500: defaultErrorHandler,
},
router: mux.NewRouter(),
moot: &sync.RWMutex{},
routes: RouteList{},
children: []*App{}... | go | {
"resource": ""
} |
q175602 | DeprecrationsCheck | test | func DeprecrationsCheck(r *Runner) error {
fmt.Println("~~~ Checking for deprecations ~~~")
b, err := ioutil.ReadFile("main.go")
if err != nil {
return err
}
if bytes.Contains(b, []byte("app.Start")) {
r.Warnings = append(r.Warnings, "app.Start has been removed in v0.11.0. Use app.Serve Instead. [main.go]")
}... | go | {
"resource": ""
} |
q175603 | List | test | func (v BaseResource) List(c Context) error {
return c.Error(404, errors.New("resource not implemented"))
} | go | {
"resource": ""
} |
q175604 | Render | test | func (s funcRenderer) Render(w io.Writer, data Data) error {
return s.renderFunc(w, data)
} | go | {
"resource": ""
} |
q175605 | Save | test | func (s *Session) Save() error {
return s.Session.Save(s.req, s.res)
} | go | {
"resource": ""
} |
q175606 | GetOnce | test | func (s *Session) GetOnce(name interface{}) interface{} {
if x, ok := s.Session.Values[name]; ok {
s.Delete(name)
return x
}
return nil
} | go | {
"resource": ""
} |
q175607 | Set | test | func (s *Session) Set(name, value interface{}) {
s.Session.Values[name] = value
} | go | {
"resource": ""
} |
q175608 | Clear | test | func (s *Session) Clear() {
for k := range s.Session.Values {
s.Delete(k)
}
} | go | {
"resource": ""
} |
q175609 | getSession | test | func (a *App) getSession(r *http.Request, w http.ResponseWriter) *Session {
if a.root != nil {
return a.root.getSession(r, w)
}
session, _ := a.SessionStore.Get(r, a.SessionName)
return &Session{
Session: session,
req: r,
res: w,
}
} | go | {
"resource": ""
} |
q175610 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, err
}
data := map[string]interface{}{
"opts": opts,
}
t := gogen.TemplateTransformer(data, template.FuncMap{})
g.Transformer(t)
g.RunFn(func(r *genny.Runner) error {
return genFile(r, ... | go | {
"resource": ""
} |
q175611 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, err
}
g.RunFn(func(r *genny.Runner) error {
if _, err := r.LookPath("npm"); err != nil {
return errors.New("could not find npm executable")
}
return nil
})
g.Box(Templates)
data :... | go | {
"resource": ""
} |
q175612 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, err
}
g.Box(packr.New("buffalo:genny:refresh", "../refresh/templates"))
ctx := plush.NewContext()
ctx.Set("app", opts.App)
g.Transformer(plushgen.Transformer(ctx))
g.Transformer(genny.Dot())... | go | {
"resource": ""
} |
q175613 | NewMessage | test | func NewMessage(settings ...MessageSetting) *Message {
m := &Message{
header: make(header),
charset: "UTF-8",
encoding: QuotedPrintable,
}
m.applySettings(settings)
if m.encoding == Base64 {
m.hEncoder = bEncoding
} else {
m.hEncoder = qEncoding
}
return m
} | go | {
"resource": ""
} |
q175614 | Reset | test | func (m *Message) Reset() {
for k := range m.header {
delete(m.header, k)
}
m.parts = nil
m.attachments = nil
m.embedded = nil
} | go | {
"resource": ""
} |
q175615 | SetHeader | test | func (m *Message) SetHeader(field string, value ...string) {
m.encodeHeader(value)
m.header[field] = value
} | go | {
"resource": ""
} |
q175616 | SetHeaders | test | func (m *Message) SetHeaders(h map[string][]string) {
for k, v := range h {
m.SetHeader(k, v...)
}
} | go | {
"resource": ""
} |
q175617 | SetAddressHeader | test | func (m *Message) SetAddressHeader(field, address, name string) {
m.header[field] = []string{m.FormatAddress(address, name)}
} | go | {
"resource": ""
} |
q175618 | FormatAddress | test | func (m *Message) FormatAddress(address, name string) string {
if name == "" {
return address
}
enc := m.encodeString(name)
if enc == name {
m.buf.WriteByte('"')
for i := 0; i < len(name); i++ {
b := name[i]
if b == '\\' || b == '"' {
m.buf.WriteByte('\\')
}
m.buf.WriteByte(b)
}
m.buf.Wri... | go | {
"resource": ""
} |
q175619 | SetDateHeader | test | func (m *Message) SetDateHeader(field string, date time.Time) {
m.header[field] = []string{m.FormatDate(date)}
} | go | {
"resource": ""
} |
q175620 | FormatDate | test | func (m *Message) FormatDate(date time.Time) string {
return date.Format(time.RFC1123Z)
} | go | {
"resource": ""
} |
q175621 | SetBody | test | func (m *Message) SetBody(contentType, body string, settings ...PartSetting) {
m.SetBodyWriter(contentType, newCopier(body), settings...)
} | go | {
"resource": ""
} |
q175622 | SetPartEncoding | test | func SetPartEncoding(e Encoding) PartSetting {
return PartSetting(func(p *part) {
p.encoding = e
})
} | go | {
"resource": ""
} |
q175623 | SetHeader | test | func SetHeader(h map[string][]string) FileSetting {
return func(f *file) {
for k, v := range h {
f.Header[k] = v
}
}
} | go | {
"resource": ""
} |
q175624 | SetCopyFunc | test | func SetCopyFunc(f func(io.Writer) error) FileSetting {
return func(fi *file) {
fi.CopyFunc = f
}
} | go | {
"resource": ""
} |
q175625 | AttachReader | test | func (m *Message) AttachReader(name string, r io.Reader, settings ...FileSetting) {
m.attachments = m.appendFile(m.attachments, fileFromReader(name, r), settings)
} | go | {
"resource": ""
} |
q175626 | Attach | test | func (m *Message) Attach(filename string, settings ...FileSetting) {
m.attachments = m.appendFile(m.attachments, fileFromFilename(filename), settings)
} | go | {
"resource": ""
} |
q175627 | EmbedReader | test | func (m *Message) EmbedReader(name string, r io.Reader, settings ...FileSetting) {
m.embedded = m.appendFile(m.embedded, fileFromReader(name, r), settings)
} | go | {
"resource": ""
} |
q175628 | Embed | test | func (m *Message) Embed(filename string, settings ...FileSetting) {
m.embedded = m.appendFile(m.embedded, fileFromFilename(filename), settings)
} | go | {
"resource": ""
} |
q175629 | ValidateTemplates | test | func ValidateTemplates(walk packd.Walker, tvs []TemplateValidator) genny.RunFn {
if len(tvs) == 0 {
return func(r *genny.Runner) error {
return nil
}
}
return func(r *genny.Runner) error {
var errs []string
err := packd.SkipWalker(walk, packd.CommonSkipPrefixes, func(path string, file packd.File) error {
... | go | {
"resource": ""
} |
q175630 | PlushValidator | test | func PlushValidator(f genny.File) error {
if !genny.HasExt(f, ".html", ".md", ".plush") {
return nil
}
_, err := plush.Parse(f.String())
return err
} | go | {
"resource": ""
} |
q175631 | Validate | test | func (opts *Options) Validate() error {
if opts.App.IsZero() {
opts.App = meta.New(".")
}
if len(opts.Name.String()) == 0 {
return errors.New("you must supply a name for your mailer")
}
return nil
} | go | {
"resource": ""
} |
q175632 | LoadPlugins | test | func LoadPlugins() error {
var err error
oncer.Do("events.LoadPlugins", func() {
// don't send plugins events during testing
if envy.Get("GO_ENV", "development") == "test" {
return
}
plugs, err := plugins.Available()
if err != nil {
err = err
return
}
for _, cmds := range plugs {
for _, c :=... | go | {
"resource": ""
} |
q175633 | WriteHeader | test | func (w *Response) WriteHeader(i int) {
w.Status = i
w.ResponseWriter.WriteHeader(i)
} | go | {
"resource": ""
} |
q175634 | Write | test | func (w *Response) Write(b []byte) (int, error) {
w.Size = binary.Size(b)
return w.ResponseWriter.Write(b)
} | go | {
"resource": ""
} |
q175635 | Flush | test | func (w *Response) Flush() {
if f, ok := w.ResponseWriter.(http.Flusher); ok {
f.Flush()
}
} | go | {
"resource": ""
} |
q175636 | CloseNotify | test | func (w *Response) CloseNotify() <-chan bool {
if cn, ok := w.ResponseWriter.(closeNotifier); ok {
return cn.CloseNotify()
}
return nil
} | go | {
"resource": ""
} |
q175637 | Run | test | func Run() error {
fmt.Printf("! This updater will attempt to update your application to Buffalo version: %s\n", runtime.Version)
if !ask("Do you wish to continue?") {
fmt.Println("~~~ cancelling update ~~~")
return nil
}
r := &Runner{
App: meta.New("."),
Warnings: []string{},
}
defer func() {
if... | go | {
"resource": ""
} |
q175638 | onlyRelevantFiles | test | func onlyRelevantFiles(p string, fi os.FileInfo, err error, fn func(p string) error) error {
if err != nil {
return err
}
if fi.IsDir() {
base := filepath.Base(p)
if strings.HasPrefix(base, "_") {
return filepath.SkipDir
}
for _, n := range []string{"vendor", "node_modules", ".git"} {
if base == n {... | go | {
"resource": ""
} |
q175639 | GoTemplateEngine | test | func GoTemplateEngine(input string, data map[string]interface{}, helpers map[string]interface{}) (string, error) {
// since go templates don't have the concept of an optional map argument like Plush does
// add this "null" map so it can be used in templates like this:
// {{ partial "flash.html" .nilOpts }}
data["ni... | go | {
"resource": ""
} |
q175640 | GET | test | func (a *App) GET(p string, h Handler) *RouteInfo {
return a.addRoute("GET", p, h)
} | go | {
"resource": ""
} |
q175641 | Redirect | test | func (a *App) Redirect(status int, from, to string) *RouteInfo {
return a.GET(from, func(c Context) error {
return c.Redirect(status, to)
})
} | go | {
"resource": ""
} |
q175642 | ANY | test | func (a *App) ANY(p string, h Handler) {
a.GET(p, h)
a.POST(p, h)
a.PUT(p, h)
a.PATCH(p, h)
a.HEAD(p, h)
a.OPTIONS(p, h)
a.DELETE(p, h)
} | go | {
"resource": ""
} |
q175643 | buildRouteName | test | func (a *App) buildRouteName(p string) string {
if p == "/" || p == "" {
return "root"
}
resultParts := []string{}
parts := strings.Split(p, "/")
for index, part := range parts {
if strings.Contains(part, "{") || part == "" {
continue
}
shouldSingularize := (len(parts) > index+1) && strings.Contains... | go | {
"resource": ""
} |
q175644 | New | test | func New(opts *Options) (*genny.Group, error) {
gg := &genny.Group{}
if err := opts.Validate(); err != nil {
return gg, err
}
if !opts.SkipInit {
g, err := initGenerator(opts)
if err != nil {
return gg, err
}
gg.Add(g)
}
g := genny.New()
h := template.FuncMap{}
data := map[string]interface{}{
... | go | {
"resource": ""
} |
q175645 | NewDialer | test | func NewDialer(host string, port int, username, password string) *Dialer {
return &Dialer{
Host: host,
Port: port,
Username: username,
Password: password,
SSL: port == 465,
Timeout: 10 * time.Second,
RetryFailure: true,
}
} | go | {
"resource": ""
} |
q175646 | Dial | test | func (d *Dialer) Dial() (SendCloser, error) {
conn, err := NetDialTimeout("tcp", addr(d.Host, d.Port), d.Timeout)
if err != nil {
return nil, err
}
if d.SSL {
conn = tlsClient(conn, d.tlsConfig())
}
c, err := smtpNewClient(conn, d.Host)
if err != nil {
return nil, err
}
if d.Timeout > 0 {
conn.SetDe... | go | {
"resource": ""
} |
q175647 | DialAndSend | test | func (d *Dialer) DialAndSend(m ...*Message) error {
s, err := d.Dial()
if err != nil {
return err
}
defer s.Close()
return Send(s, m...)
} | go | {
"resource": ""
} |
q175648 | Set | test | func (f Flash) Set(key string, values []string) {
f.data[key] = values
} | go | {
"resource": ""
} |
q175649 | Add | test | func (f Flash) Add(key, value string) {
if len(f.data[key]) == 0 {
f.data[key] = []string{value}
return
}
f.data[key] = append(f.data[key], value)
} | go | {
"resource": ""
} |
q175650 | persist | test | func (f Flash) persist(session *Session) {
b, _ := json.Marshal(f.data)
session.Set(flashKey, b)
session.Save()
} | go | {
"resource": ""
} |
q175651 | newFlash | test | func newFlash(session *Session) *Flash {
result := &Flash{
data: map[string][]string{},
}
if session.Session != nil {
if f := session.Get(flashKey); f != nil {
json.Unmarshal(f.([]byte), &result.data)
}
}
return result
} | go | {
"resource": ""
} |
q175652 | Get | test | func (c *Cookies) Get(name string) (string, error) {
ck, err := c.req.Cookie(name)
if err != nil {
return "", err
}
return ck.Value, nil
} | go | {
"resource": ""
} |
q175653 | Set | test | func (c *Cookies) Set(name, value string, maxAge time.Duration) {
ck := http.Cookie{
Name: name,
Value: value,
MaxAge: int(maxAge.Seconds()),
}
http.SetCookie(c.res, &ck)
} | go | {
"resource": ""
} |
q175654 | SetWithExpirationTime | test | func (c *Cookies) SetWithExpirationTime(name, value string, expires time.Time) {
ck := http.Cookie{
Name: name,
Value: value,
Expires: expires,
}
http.SetCookie(c.res, &ck)
} | go | {
"resource": ""
} |
q175655 | Delete | test | func (c *Cookies) Delete(name string) {
ck := http.Cookie{
Name: name,
Value: "v",
// Setting a time in 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)
} | go | {
"resource": ""
} |
q175656 | NewMessage | test | func NewMessage() Message {
return Message{
Context: context.Background(),
Headers: map[string]string{},
Data: render.Data{},
moot: &sync.RWMutex{},
}
} | go | {
"resource": ""
} |
q175657 | NewFromData | test | func NewFromData(data render.Data) Message {
d := render.Data{}
for k, v := range data {
d[k] = v
}
m := NewMessage()
m.Data = d
return m
} | go | {
"resource": ""
} |
q175658 | New | test | func New(c buffalo.Context) Message {
m := NewFromData(c.Data())
m.Context = c
return m
} | go | {
"resource": ""
} |
q175659 | CloseNotify | test | func (es *EventSource) CloseNotify() <-chan bool {
if cn, ok := es.w.(closeNotifier); ok {
return cn.CloseNotify()
}
return nil
} | go | {
"resource": ""
} |
q175660 | NewEventSource | test | func NewEventSource(w http.ResponseWriter) (*EventSource, error) {
es := &EventSource{w: w}
var ok bool
es.fl, ok = w.(http.Flusher)
if !ok {
return es, errors.New("streaming is not supported")
}
es.w.Header().Set("Content-Type", "text/event-stream")
es.w.Header().Set("Cache-Control", "no-cache")
es.w.Header... | go | {
"resource": ""
} |
q175661 | NewSimpleWithContext | test | func NewSimpleWithContext(ctx context.Context) *Simple {
ctx, cancel := context.WithCancel(ctx)
l := logrus.New()
l.Level = logrus.InfoLevel
l.Formatter = &logrus.TextFormatter{}
return &Simple{
Logger: l,
ctx: ctx,
cancel: cancel,
handlers: map[string]Handler{},
moot: &sync.Mutex{},
}
} | go | {
"resource": ""
} |
q175662 | Register | test | func (w *Simple) Register(name string, h Handler) error {
w.moot.Lock()
defer w.moot.Unlock()
if _, ok := w.handlers[name]; ok {
return fmt.Errorf("handler already mapped for name %s", name)
}
w.handlers[name] = h
return nil
} | go | {
"resource": ""
} |
q175663 | Start | test | func (w *Simple) Start(ctx context.Context) error {
w.Logger.Info("Starting Simple Background Worker")
w.ctx, w.cancel = context.WithCancel(ctx)
return nil
} | go | {
"resource": ""
} |
q175664 | Stop | test | func (w Simple) Stop() error {
w.Logger.Info("Stopping Simple Background Worker")
w.cancel()
return nil
} | go | {
"resource": ""
} |
q175665 | Perform | test | func (w Simple) Perform(job Job) error {
w.Logger.Debugf("Performing job %s", job)
if job.Handler == "" {
err := fmt.Errorf("no handler name given for %s", job)
w.Logger.Error(err)
return err
}
w.moot.Lock()
defer w.moot.Unlock()
if h, ok := w.handlers[job.Handler]; ok {
go func() {
err := safe.RunE(fu... | go | {
"resource": ""
} |
q175666 | PerformAt | test | func (w Simple) PerformAt(job Job, t time.Time) error {
return w.PerformIn(job, time.Until(t))
} | go | {
"resource": ""
} |
q175667 | PerformIn | test | func (w Simple) PerformIn(job Job, d time.Duration) error {
go func() {
select {
case <-time.After(d):
w.Perform(job)
case <-w.ctx.Done():
w.cancel()
}
}()
return nil
} | go | {
"resource": ""
} |
q175668 | String | test | func (ri RouteInfo) String() string {
b, _ := json.MarshalIndent(ri, "", " ")
return string(b)
} | go | {
"resource": ""
} |
q175669 | Alias | test | func (ri *RouteInfo) Alias(aliases ...string) *RouteInfo {
ri.Aliases = append(ri.Aliases, aliases...)
for _, a := range aliases {
ri.App.router.Handle(a, ri).Methods(ri.Method)
}
return ri
} | go | {
"resource": ""
} |
q175670 | Name | test | func (ri *RouteInfo) Name(name string) *RouteInfo {
routeIndex := -1
for index, route := range ri.App.Routes() {
if route.Path == ri.Path && route.Method == ri.Method {
routeIndex = index
break
}
}
name = flect.Camelize(name)
if !strings.HasSuffix(name, "Path") {
name = name + "Path"
}
ri.PathName... | go | {
"resource": ""
} |
q175671 | BuildPathHelper | test | func (ri *RouteInfo) BuildPathHelper() RouteHelperFunc {
cRoute := ri
return func(opts map[string]interface{}) (template.HTML, error) {
pairs := []string{}
for k, v := range opts {
pairs = append(pairs, k)
pairs = append(pairs, fmt.Sprintf("%v", v))
}
url, err := cRoute.MuxRoute.URL(pairs...)
if err ... | go | {
"resource": ""
} |
q175672 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, err
}
g.Transformer(genny.Replace("-no-pop", ""))
g.Transformer(genny.Dot())
box := packr.New("buffalo:genny:ci", "../ci/templates")
var fname string
switch opts.Provider {
case "travis"... | go | {
"resource": ""
} |
q175673 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, err
}
g.RunFn(construct(opts))
return g, nil
} | go | {
"resource": ""
} |
q175674 | RegisterCustomDecoder | test | func RegisterCustomDecoder(fn CustomTypeDecoder, types []interface{}, fields []interface{}) {
rawFunc := (func([]string) (interface{}, error))(fn)
decoder.RegisterCustomType(rawFunc, types, fields)
} | go | {
"resource": ""
} |
q175675 | Replace | test | func (ms *MiddlewareStack) Replace(mw1 MiddlewareFunc, mw2 MiddlewareFunc) {
m1k := funcKey(mw1)
stack := []MiddlewareFunc{}
for _, mw := range ms.stack {
if funcKey(mw) == m1k {
stack = append(stack, mw2)
} else {
stack = append(stack, mw)
}
}
ms.stack = stack
} | go | {
"resource": ""
} |
q175676 | Routes | test | func (a *App) Routes() RouteList {
if a.root != nil {
return a.root.routes
}
return a.routes
} | go | {
"resource": ""
} |
q175677 | WrapBuffaloHandler | test | func WrapBuffaloHandler(h Handler) http.Handler {
a := New(Options{})
// it doesn't matter what we actually map it
// GET, POST, etc... we just need the underlying
// RouteInfo, which implements http.Handler
ri := a.GET("/", h)
return ri
} | go | {
"resource": ""
} |
q175678 | PackageJSONCheck | test | func PackageJSONCheck(r *Runner) error {
fmt.Println("~~~ Checking package.json ~~~")
if !r.App.WithWebpack {
return nil
}
box := webpack.Templates
f, err := box.FindString("package.json.tmpl")
if err != nil {
return err
}
tmpl, err := template.New("package.json").Parse(f)
if err != nil {
return err
... | go | {
"resource": ""
} |
q175679 | match | test | func (c ImportConverter) match(importpath string) (string, bool) {
for key, value := range c.Data {
if !strings.HasPrefix(importpath, key) {
continue
}
result := strings.Replace(importpath, key, value, 1)
return result, true
}
return importpath, false
} | go | {
"resource": ""
} |
q175680 | Send | test | func Send(s Sender, msg ...*Message) error {
for i, m := range msg {
if err := send(s, m); err != nil {
return &SendError{Cause: err, Index: uint(i)}
}
}
return nil
} | go | {
"resource": ""
} |
q175681 | Last | test | func (opts Options) Last(n name.Ident) bool {
return opts.Parts[len(opts.Parts)-1].String() == n.String()
} | go | {
"resource": ""
} |
q175682 | Stop | test | func (a *App) Stop(err error) error {
a.cancel()
if err != nil && errors.Cause(err) != context.Canceled {
a.Logger.Error(err)
return err
}
return nil
} | go | {
"resource": ""
} |
q175683 | DepEnsure | test | func DepEnsure(r *Runner) error {
if r.App.WithPop {
upkg = append(upkg, "github.com/gobuffalo/fizz", "github.com/gobuffalo/pop")
}
if !r.App.WithDep {
fmt.Println("~~~ Running go get ~~~")
return modGetUpdate(r)
}
fmt.Println("~~~ Running dep ensure ~~~")
return runDepEnsure(r)
} | go | {
"resource": ""
} |
q175684 | String | test | func (b BuildInfo) String() string {
return fmt.Sprintf("%s (%s)", b.Version, b.Time)
} | go | {
"resource": ""
} |
q175685 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, err
}
if !opts.SkipTemplates {
core := packr.New("github.com/gobuffalo/buffalo/genny/resource/templates/core", "../resource/templates/core")
if err := g.Box(core); err != nil {
return g... | go | {
"resource": ""
} |
q175686 | AddBody | test | func (m *Message) AddBody(r render.Renderer, data render.Data) error {
buf := bytes.NewBuffer([]byte{})
err := r.Render(buf, m.merge(data))
if err != nil {
return err
}
m.Bodies = append(m.Bodies, Body{
Content: buf.String(),
ContentType: r.ContentType(),
})
return nil
} | go | {
"resource": ""
} |
q175687 | AddBodies | test | func (m *Message) AddBodies(data render.Data, renderers ...render.Renderer) error {
for _, r := range renderers {
err := m.AddBody(r, data)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q175688 | AddAttachment | test | func (m *Message) AddAttachment(name, contentType string, r io.Reader) error {
m.Attachments = append(m.Attachments, Attachment{
Name: name,
ContentType: contentType,
Reader: r,
Embedded: false,
})
return nil
} | go | {
"resource": ""
} |
q175689 | AddEmbedded | test | func (m *Message) AddEmbedded(name string, r io.Reader) error {
m.Attachments = append(m.Attachments, Attachment{
Name: name,
Reader: r,
Embedded: true,
})
return nil
} | go | {
"resource": ""
} |
q175690 | SetHeader | test | func (m *Message) SetHeader(field, value string) {
m.Headers[field] = value
} | go | {
"resource": ""
} |
q175691 | New | test | func New(opts *Options) (*genny.Group, error) {
if err := opts.Validate(); err != nil {
return nil, err
}
gg, err := core.New(opts.Options)
if err != nil {
return gg, err
}
g := genny.New()
g.Transformer(genny.Dot())
data := map[string]interface{}{
"opts": opts,
}
helpers := template.FuncMap{}
t :=... | go | {
"resource": ""
} |
q175692 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
g.Box(packr.New("buffalo:genny:assets:standard", "../standard/templates"))
data := map[string]interface{}{}
h := template.FuncMap{}
t := gogen.TemplateTransformer(data, h)
g.Transformer(t)
g.RunFn(func(r *genny.Runner) error {
f, err := r.F... | go | {
"resource": ""
} |
q175693 | New | test | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, errors.WithStack(err)
}
g.RunFn(appDetails(opts))
cBox := packr.Folder(filepath.Join(opts.App.Root, "config"))
g.RunFn(configs(opts, cBox))
aBox := packr.Folder(opts.App.Root)
g.RunFn(pkg... | go | {
"resource": ""
} |
q175694 | Cleanup | test | func Cleanup(opts *Options) genny.RunFn {
return func(r *genny.Runner) error {
defer os.RemoveAll(filepath.Join(opts.Root, "a"))
if err := jam.Clean(); err != nil {
return err
}
var err error
opts.rollback.Range(func(k, v interface{}) bool {
f := genny.NewFileS(k.(string), v.(string))
r.Logger.Debu... | go | {
"resource": ""
} |
q175695 | MDTemplateEngine | test | func MDTemplateEngine(input string, data map[string]interface{}, helpers map[string]interface{}) (string, error) {
if ct, ok := data["contentType"].(string); ok && ct == "text/plain" {
return plush.BuffaloRenderer(input, data, helpers)
}
source := github_flavored_markdown.Markdown([]byte(input))
source = []byte(h... | go | {
"resource": ""
} |
q175696 | Update | test | func Update(fg FileGetter, kc corev1.ConfigMapInterface, name, namespace string, updates []ConfigMapUpdate, logger *logrus.Entry) error {
cm, getErr := kc.Get(name, metav1.GetOptions{})
isNotFound := errors.IsNotFound(getErr)
if getErr != nil && !isNotFound {
return fmt.Errorf("failed to fetch current state of con... | go | {
"resource": ""
} |
q175697 | FilterChanges | test | func FilterChanges(cfg plugins.ConfigUpdater, changes []github.PullRequestChange, log *logrus.Entry) map[ConfigMapID][]ConfigMapUpdate {
toUpdate := map[ConfigMapID][]ConfigMapUpdate{}
for _, change := range changes {
var cm plugins.ConfigMapSpec
found := false
for key, configMap := range cfg.Maps {
var mat... | go | {
"resource": ""
} |
q175698 | getLabelsFromREMatches | test | func getLabelsFromREMatches(matches [][]string) (labels []string) {
for _, match := range matches {
for _, label := range strings.Split(match[0], " ")[1:] {
label = strings.ToLower(match[1] + "/" + strings.TrimSpace(label))
labels = append(labels, label)
}
}
return
} | go | {
"resource": ""
} |
q175699 | getLabelsFromGenericMatches | test | func getLabelsFromGenericMatches(matches [][]string, additionalLabels []string) []string {
if len(additionalLabels) == 0 {
return nil
}
var labels []string
for _, match := range matches {
parts := strings.Split(match[0], " ")
if ((parts[0] != "/label") && (parts[0] != "/remove-label")) || len(parts) != 2 {
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.