Buffalo Documentation

https://gobuffalo.io/documentation
Admin
Buffalo is a web development framework for Go that aims to provide a rapid and efficient way to...
Tokens:127,805
Snippets:469
Trust Score:8.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Buffalo Plugins

Source: https://gobuffalo.io/documentation/guides/plugins

Illustrates how to install Buffalo plugins. The `buffalo plugins install` command can automatically create or update the `config/buffalo-plugins.toml` file and perform `go get` for the specified plugins.

```shell
$ buffalo plugins install github.com/markbates/buffalo-trash github.com/gobuffalo/buffalo-heroku

go get github.com/gobuffalo/buffalo-heroku
go get github.com/gobuffalo/buffalo-pop
go get github.com/markbates/buffalo-trash
./config/buffalo-plugins.toml

$ buffalo plugins list

Bin            |Command               |Description
---            |---                   |---
buffalo-pop    |buffalo db            |[DEPRECATED] please use `buffalo pop` instead.
buffalo-heroku |buffalo heroku        |helps with heroku setup and deployment for buffalo applications
buffalo-pop    |buffalo destroy model |Destroys model files.
buffalo-pop    |buffalo pop           |A tasty treat for all your database needs
buffalo-trash  |buffalo trash         |destroys and recreates a buffalo app
```

--------------------------------

### Yarn Dependency Management Setup

Source: https://gobuffalo.io/documentation/getting_started/new-project

This snippet details the commands used to set up Yarn for managing project dependencies. It includes checking the Yarn version, setting the version to Berry, configuring global caching, filtering logs, and performing the initial installation.

```shell
yarn --version
yarn set version berry
yarn config set enableGlobalCache true
yarn config set logFilters --json "[{\"code\":\"YN0013\",\"level\":\"discard\"}]"
yarn --version
yarn install
```

--------------------------------

### Install Buffalo via Scoop (Windows)

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs the Buffalo framework using the Scoop package manager on Windows. Ensure Scoop is installed and configured in your PATH.

```powershell
PS C:\> scoop install buffalo
```

--------------------------------

### Install Buffalo via GoFish (Cross-Platforms)

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs the Buffalo framework using GoFish, a cross-platform package manager for Windows, macOS, and Linux. Ensure GoFish is installed.

```shell
$ gofish install buffalo
==> Installing buffalo...
🐠  buffalo : installed in 3.223672926s
```

--------------------------------

### Install GCC for Windows (via Scoop)

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs GCC on Windows using the Scoop package manager, which is a prerequisite for custom Buffalo installations with SQLite3 support on Windows.

```powershell
PS C:\> scoop install gcc
```

--------------------------------

### Start Buffalo App as Daemon

Source: https://gobuffalo.io/documentation/deploy/proxy

Demonstrates how to start a Buffalo application as a background process using shell commands. This is often a prerequisite for proxying.

```bash
# Env config
ADDR=0.0.0.0
PORT=80

# Start your app as a daemon, for example:
./myapp &
```

--------------------------------

### Install buffalo-plugins

Source: https://gobuffalo.io/documentation/guides/plugins

Installs the core buffalo-plugins package to enable plugin functionality. This command uses the Go toolchain to fetch and install the specified package.

```shell
$ go get -u -v github.com/gobuffalo/buffalo-plugins
```

--------------------------------

### Example Database Configuration (YAML)

Source: https://gobuffalo.io/documentation/database/configuration

Shows a typical database.yml structure using Go templating for environment variable substitution, demonstrating how to configure development, test, and production environments.

```YAML
development:
  dialect: postgres
  database: myapp_development
  host: localhost
  user: postgres
  password: ""
  pool: 10

test:
  url: "envOr \"TEST_DATABASE_URL\" \"postgres://postgres:postgres@localhost:5432/myapp_test\""
  pool: 1

production:
  url: "envOr \"DATABASE_URL\" \"postgres://postgres:postgres@localhost:5432/myapp_production\""
  pool: 20
```

--------------------------------

### Example Standard Layout File

Source: https://gobuffalo.io/documentation/frontend-layer/layouts

An example of a standard HTML layout file, typically named something like 'application.plush.html'. It includes basic HTML structure and uses the `<%= yield %>` directive to insert content from the rendered template.

```html
<html>
  <head>
    <title>My App</title>
  </head>
  <body>
    <div id="main">
      <%= yield %>
    </div>
  </body>
</html>
```

--------------------------------

### Install Buffalo via Chocolatey (Windows)

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs the Buffalo framework using the Chocolatey package manager on Windows. Note that versions on Chocolatey may have a delay due to moderation.

```powershell
PS C:\> choco install buffalo
```

--------------------------------

### Custom Install Buffalo with SQLite3 Support

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs Buffalo with SQLite3 support using the Go toolchain. This requires a GCC or equivalent C compiler to be installed beforehand for the go-sqlite3 dependency.

```go
$ go install -tags sqlite github.com/gobuffalo/cli/cmd/buffalo@
```

--------------------------------

### Running Buffalo Tests

Source: https://gobuffalo.io/documentation/guides/testing

Demonstrates the output of the `buffalo test` command, which handles test environment setup, database schema loading, and test execution across project packages.

```shell
$ buffalo test

dropped database authrecipe_test
created database authrecipe_test
dumped schema for authrecipe_development
loaded schema for authrecipe_test
go test -p 1 github.com/gobuffalo/authrecipe github.com/gobuffalo/authrecipe/actions github.com/gobuffalo/authrecipe/grifts github.com/gobuffalo/authrecipe/models
?   	github.com/gobuffalo/authrecipe	[no test files]
ok  	github.com/gobuffalo/authrecipe/actions	0.640s
?   	github.com/gobuffalo/authrecipe/grifts	[no test files]
ok  	github.com/gobuffalo/authrecipe/models	0.327s

```

--------------------------------

### Buffalo New Command Configuration File Example

Source: https://gobuffalo.io/documentation/getting_started/new-project

An example of a '.buffalo.yml' configuration file used to override default settings for the 'buffalo new' command. This allows for persistent customization of application generation parameters.

```yaml
skip-yarn: true
db-type: postgres
bootstrap: 4
with-dep: true
```

--------------------------------

### Install Soda CLI from Source (With SQLite)

Source: https://gobuffalo.io/documentation/database/soda

Installs the Soda CLI from source for Go version 1.16 and later, including SQLite support. Requires a C compiler (like GCC) to be installed.

```go
go install -tags sqlite github.com/gobuffalo/pop/v6/soda@latest
```

--------------------------------

### Example .env Configuration

Source: https://gobuffalo.io/documentation/getting_started/configuration

An example of a .env file used by Buffalo to configure application environment variables. These variables are loaded by the envy.Load function at application startup. The file is typically ignored by version control systems like Git.

```dotenv
SENDGRID_API_KEY=ABCCOQ7GFRVCW0ODHPFQ3FTP5SLL1Q
SENDGRID_EMAIL=email@myapp.com

APP_DEBUG=true
APP_LOG_LEVEL=debug
APP_URL=https://myapp.com
```

--------------------------------

### Buffalo Plugins Configuration File

Source: https://gobuffalo.io/documentation/guides/plugins

Example TOML configuration file listing registered Buffalo plugins, including their binary names and Go module paths.

```toml
[[plugin]]
  binary = "buffalo-pop"
  go_get = "github.com/gobuffalo/buffalo-pop"

[[plugin]]
  binary = "buffalo-trash"
  go_get = "github.com/markbates/buffalo-trash"
```

--------------------------------

### Install buffalo-auth Plugin

Source: https://gobuffalo.io/documentation/guides/auth

This snippet shows the command to install the `buffalo-auth` plugin, which is required for native authentication support in Buffalo applications. The command should be executed from the project's root directory.

```shell
$ buffalo plugins install github.com/gobuffalo/buffalo-auth
```

--------------------------------

### Install Buffalo on GNU/Linux

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs the Buffalo CLI tool on GNU/Linux systems using wget to download the archive and tar to extract it. The binary is then moved to /usr/local/bin for system-wide access, requiring sudo privileges.

```Shell
$ wget https://github.com/gobuffalo/cli/releases/download//buffalo__Linux_x86_64.tar.gz
$ tar -xvzf buffalo__Linux_x86_64.tar.gz
$ sudo mv buffalo /usr/local/bin/buffalo
```

--------------------------------

### Example Stylesheet Tag Generation

Source: https://gobuffalo.io/documentation/frontend-layer/assets

Demonstrates the stylesheetTag helper's output, creating a link tag for a fingerprinted CSS file.

```html
<%= stylesheetTag("application.css") %>
// Returns: <link href="/assets/application.bd76587ded82386f388f.css" media="screen" rel="stylesheet" />
```

--------------------------------

### Example Content Template

Source: https://gobuffalo.io/documentation/frontend-layer/layouts

A simple template file that would be rendered within the layout. The content from this template is injected into the layout via the `<%= yield %>` placeholder.

```plush
<h1>Hello!!</h1>
```

--------------------------------

### Install Buffalo App Executable

Source: https://gobuffalo.io/documentation/deploy/systemd

Commands to move the Buffalo application executable to a standard location and set appropriate ownership and execute permissions.

```shell
sudo mv myapp /usr/local/bin
sudo chown root: /usr/local/bin/myapp
sudo chmod +x /usr/local/bin/myapp
```

--------------------------------

### List Buffalo Plugins (Without Configuration)

Source: https://gobuffalo.io/documentation/guides/plugins

Shows the output of listing Buffalo plugins when no `config/buffalo-plugins.toml` file exists. Buffalo scans system paths to find all installed plugins.

```shell
$ buffalo plugins list

Bin              |Command                    |Description
---              |---                        |---
buffalo-auth     |buffalo generate auth      |Generates a full auth implementation
buffalo-pop      |buffalo db                 |[DEPRECATED] please use `buffalo pop` instead.
buffalo-goth     |buffalo generate goth-auth |Generates a full auth implementation use Goth
buffalo-goth     |buffalo generate goth      |generates a actions/auth.go file configured to the specified providers.
buffalo-heroku   |buffalo heroku             |helps with heroku setup and deployment for buffalo applications
buffalo-plugins  |buffalo events listen      |listens to github.com/gobuffalo/events
buffalo-pop      |buffalo destroy model      |Destroys model files.
buffalo-plugins  |buffalo generate plugin    |generates a new buffalo plugin
buffalo-plugins  |buffalo plugins            |tools for working with buffalo plugins
buffalo-pop      |buffalo pop                |A tasty treat for all your database needs
buffalo-trash    |buffalo trash              |destroys and recreates a buffalo app
buffalo-upgradex |buffalo upgradex           |updates Buffalo and/or Pop/Soda as well as your app
```

--------------------------------

### List Installed Buffalo Plugins

Source: https://gobuffalo.io/documentation/guides/plugins

Command to display a list of currently configured Buffalo plugins, showing their binary names, associated commands, and descriptions.

```shell
$ buffalo plugins list

Bin           |Command               |Description
---           |---                   |---
buffalo-pop   |buffalo db            |[DEPRECATED] please use `buffalo pop` instead.
buffalo-pop   |buffalo destroy model |Destroys model files.
buffalo-pop   |buffalo pop           |A tasty treat for all your database needs
buffalo-trash |buffalo trash         |destroys and recreates a buffalo app
```

--------------------------------

### Using Buffalo Development Branch

Source: https://gobuffalo.io/documentation/guides/gomods

Demonstrates how to obtain and utilize the latest bleeding-edge version of Buffalo by specifying the `@development` tag with `go get` and then tidying dependencies with `go mod tidy`.

```bash
$ go get -u github.com/gobuffalo/buffalo@development
$ go mod tidy
```

--------------------------------

### Git Initialization and Commit

Source: https://gobuffalo.io/documentation/getting_started/new-project

This snippet outlines the standard Git commands to initialize a new repository, stage all project files, and create the initial commit.

```shell
git init
git add .
git commit -q -m Initial Commit
```

--------------------------------

### Install Soda CLI via Homebrew

Source: https://gobuffalo.io/documentation/database/soda

Installs the Soda CLI using Homebrew on macOS. This method ensures you get the latest version with SQLite support pre-compiled.

```shell
brew install gobuffalo/tap/pop
```

--------------------------------

### Fix NPM Permissions Errors

Source: https://gobuffalo.io/documentation/troubleshooting

Addresses `buffalo new` failures caused by incorrect Node/NPM setup, specifically related to global package installation permissions. Consult the provided npm documentation for detailed steps.

```APIDOC
External Documentation:
  URL: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally
  Purpose: Guide to fixing NPM permission errors when installing packages globally.
```

--------------------------------

### Initialize SMTP Sender and Send Contact Message

Source: https://gobuffalo.io/documentation/guides/mailers

Demonstrates initializing an SMTP sender with environment variables and sending a contact message. It includes setting up the mailer, creating a new message, adding HTML and plain text bodies using a render engine, and sending the email.

```go
package x

import (
  "log"

  "github.com/gobuffalo/buffalo/render"
  "github.com/gobuffalo/envy"
  "github.com/gobuffalo/packr"
  "github.com/gobuffalo/plush"
  "github.com/gobuffalo/buffalo/mail"
  "github.com/pkg/errors"
  "gitlab.com/wawandco/app/models"
)

var smtp mail.Sender
var r *render.Engine

func init() {

  // Pulling config from the env.
  port := envy.Get("SMTP_PORT", "1025")
  host := envy.Get("SMTP_HOST", "localhost")
  user := envy.Get("SMTP_USER", "")
  password := envy.Get("SMTP_PASSWORD", "")

  var err error
  smtp, err = mail.NewSMTPSender(host, port, user, password)

  if err != nil {
    log.Fatal(err)
  }

  // The rendering engine, this is usually generated inside actions/render.go in your buffalo app.
  r = render.New(render.Options{
    TemplatesBox:   packr.NewBox("../templates"),
  })
}

// SendContactMessage Sends contact message to contact@myapp.com
func SendContactMessage(c *models.Contact) error {

  // Creates a new message
  m := mail.NewMessage()
  m.From = "sender@myapp.com"
  m.Subject = "New Contact"
  m.To = []string{"contact@myapp.com"}

  // Data that will be used inside the templates when rendering.
  data := map[string]interface{}{
    "contact": c,
  }

  // You can add multiple bodies to the message you're creating to have content-types alternatives.
  err := m.AddBodies(data, r.HTML("mail/contact.html"), r.Plain("mail/contact.txt"))

  if err != nil {
    return errors.WithStack(err)
  }

  err = smtp.Send(m)
  if err != nil {
    return errors.WithStack(err)
  }

  return nil
}

```

--------------------------------

### Populate Sample Data (Go)

Source: https://gobuffalo.io/documentation/database/relations

This Go code snippet demonstrates how to create sample User and Book records in a database using the Pop ORM. It sets up the necessary data structures and transaction context for subsequent examples.

```go
for i := 0; i < 3; i++ {
  user := User{ID: i + 1}
  tx.Create(&user)
}

for i := 0; i < 3; i++ {
  book := Book{UserID: i +1}
  tx.Create(&book)
}
```

--------------------------------

### Register Buffalo Routes in app.go (Go)

Source: https://gobuffalo.io/documentation/request_handling/actions

Illustrates how Buffalo automatically registers generated action routes within the application's main routing file. This example shows GET routes for 'show', 'index', and 'create' actions for the 'users' resource.

```go
// actions/app.go

app.GET("/users/show", UsersShow)
app.GET("/users/index", UsersIndex)
app.GET("/users/create", UsersCreate)

```

--------------------------------

### Listen for Global Events in Go

Source: https://gobuffalo.io/documentation/guides/events

Demonstrates how to register a listener function to receive global event messages emitted by the `github.com/gobuffalo/events` package. The listener is registered in an `init` function, ensuring it's active when the application starts. The provided example shows a basic listener that can perform actions based on received events.

```Go
package main

import (
	"fmt"
	"github.com/gobuffalo/events"
)

func init() {
	_, err := events.Listen(func(e events.Event) {
		fmt.Printf("Received event: %s\n", e.Name)
		// Process the event data as needed
		// fmt.Printf("Event data: %+v\n", e.Data)
	})

	if err != nil {
		fmt.Printf("Error registering event listener: %v\n", err)
	}
}

func main() {
	// Example of emitting an event (optional, for demonstration)
	// events.Emit(events.Event{Name: "user.created", Data: map[string]interface{}{"userID": 123}})

	// Keep the application running to receive events
	select {}
}
```

--------------------------------

### Install Buffalo via Homebrew (macOS)

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs the Buffalo framework on macOS using the Homebrew package manager. This requires Homebrew to be installed first.

```shell
brew install gobuffalo/tap/buffalo
```

--------------------------------

### Buffalo Project Generation Output

Source: https://gobuffalo.io/documentation/getting_started/new-project

Detailed output showing the files and commands executed during the creation of a new Buffalo project. This includes Go module initialization, file generation, and dependency setup.

```shell
$ buffalo new coke
DEBU[2022-05-25T11:06:33-05:00] Step: 435aea40
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] Exec: go mod init coke
go: creating new go.mod: module coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/README.md
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/actions_test.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/app.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/home.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/home_test.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/actions/render.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/cmd/app/main.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.codeclimate.yml
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.env
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/fixtures/sample.toml
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/grifts/init.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/inflections.json
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/config/buffalo-app.toml
DEBU[2022-05-25T11:06:33-05:00] Step: 638bde0d
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/Dockerfile
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.dockerignore
DEBU[2022-05-25T11:06:33-05:00] Step: 7065092d
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/grifts/db.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/models/models.go
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/models/models_test.go
DEBU[2022-05-25T11:06:33-05:00] Step: 916dfca0
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/database.yml
DEBU[2022-05-25T11:06:33-05:00] Step: ff1c6d38
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] File: /your/path/coke/.buffalo.dev.yml
DEBU[2022-05-25T11:06:33-05:00] Step: 103396c6
DEBU[2022-05-25T11:06:33-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:33-05:00] Exec: go install github.com/gobuffalo/buffalo-pop/v3@latest
DEBU[2022-05-25T11:06:34-05:00] Step: ae1260b1
DEBU[2022-05-25T11:06:34-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/config/buffalo-plugins.toml
DEBU[2022-05-25T11:06:34-05:00] Step: 4992ff46
DEBU[2022-05-25T11:06:34-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/app.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/home.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/home_test.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/actions/render.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/locales/all.en-us.yaml
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/locales/embed.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/public/embed.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/public/robots.txt
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/_flash.plush.html
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/application.plush.html
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/embed.go
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/templates/home/index.plush.html
DEBU[2022-05-25T11:06:34-05:00] Step: 69d71878
DEBU[2022-05-25T11:06:34-05:00] Chdir: /your/path/coke
DEBU[2022-05-25T11:06:34-05:00] LookPath: yarn
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/css/_buffalo.scss
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/css/application.scss
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/images/favicon.ico
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/images/logo.svg
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/assets/js/application.js
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/.babelrc
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/package.json
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/postcss.config.js
DEBU[2022-05-25T11:06:34-05:00] File: /your/path/coke/public/assets/keep

```

--------------------------------

### Custom Install Buffalo without SQLite3 Support

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs Buffalo without SQLite3 support using the Go toolchain. This is a simpler installation if SQLite3 is not required.

```go
$ go install github.com/gobuffalo/cli/cmd/buffalo@
```

--------------------------------

### Create New Buffalo Project

Source: https://gobuffalo.io/documentation/getting_started/new-project

Uses the Buffalo CLI to generate a new web application. This command initializes the project structure and dependencies.

```shell
$ buffalo new coke

```

--------------------------------

### Configure Standard Application Instance

Source: https://gobuffalo.io/documentation/guides/apis

Defines the main application instance for a standard web project. It includes middleware for CSRF protection, database transactions, and serving static assets from the public directory.

```go
func App() *buffalo.App {
	if app == nil {
		app = buffalo.New(buffalo.Options{
			Env:         ENV,
			SessionName: "_coke_session",
		})
		app.Use(forceSSL())
		app.Use(paramlogger.ParameterLogger)
		app.Use(csrf.New)
		app.Use(popmw.Transaction(models.DB))
		app.Use(translations())
		app.GET("/", HomeHandler)
		app.ServeFiles("/", http.FS(public.FS())) // serve files from the public directory
	}

	return app
}
```

--------------------------------

### Go Module Management and Download

Source: https://gobuffalo.io/documentation/getting_started/new-project

This section covers the Go commands for managing project dependencies. It includes tidying up the go.mod file to ensure all dependencies are accounted for and downloading any missing modules.

```go
go mod tidy
go mod download
```

--------------------------------

### Resolve `go get` Directory Layout Error

Source: https://gobuffalo.io/documentation/troubleshooting

Fixes the `unexpected directory layout` error during `go get` on Buffalo, often related to vendor directory structures. Rerunning `go get` typically resolves this issue by correcting the layout.

```go
# Rerun go get to resolve directory layout issues
go get github.com/gobuffalo/buffalo
```

--------------------------------

### Install Soda CLI from Source (No SQLite)

Source: https://gobuffalo.io/documentation/database/soda

Installs the Soda CLI from source for Go version 1.16 and later. This build does not include SQLite support.

```go
go install github.com/gobuffalo/pop/v6/soda@latest
```

--------------------------------

### Verify Buffalo Installation

Source: https://gobuffalo.io/documentation/getting_started/installation

Checks if the Buffalo installation was successful by running the `buffalo` command in the terminal. A successful output shows the Buffalo CLI usage information.

```shell
$ buffalo
Build Buffalo applications with ease

Usage:
  buffalo [command]

Available Commands:
  build       Build the application binary, including bundling of webpack assets
  completion  Generate the autocompletion script for the specified shell
  db          [PLUGIN] [DEPRECATED] please use `buffalo pop` instead.
  destroy     Destroy generated components
  dev         Run the Buffalo app in 'development' mode
  fix         Attempt to fix a Buffalo applications API to match version v0.18.6
  generate    Generate application components
  help        Help about any command
  info        Print diagnostic information (useful for debugging)
  new         Creates a new Buffalo application
  plugins     tools for working with buffalo plugins
  pop         [PLUGIN] A tasty treat for all your database needs
  routes      Print all defined routes
  setup       Setup a newly created, or recently checked out application.
  task        Run grift tasks
  test        Run the tests for the Buffalo app. Use --force-migrations to skip schema load.
  version     Print the version information

Flags:
  -h, --help   help for buffalo

Use "buffalo [command] --help" for more information about a command.
```

--------------------------------

### List Buffalo Plugins (With Configuration)

Source: https://gobuffalo.io/documentation/guides/plugins

Demonstrates how to list available Buffalo plugins when a `config/buffalo-plugins.toml` file is present. The output is scoped to plugins defined in the configuration.

```shell
$ cat config/buffalo-plugins.toml

[[plugin]]
  binary = "buffalo-pop"
  go_get = "github.com/gobuffalo/buffalo-pop"

$ buffalo plugins list

Bin         |Command               |Description
---         |---                   |---
buffalo-pop |buffalo db            |[DEPRECATED] please use `buffalo pop` instead.
buffalo-pop |buffalo destroy model |Destroys model files.
buffalo-pop |buffalo pop           |A tasty treat for all your database needs
```

--------------------------------

### Create Standard Buffalo Application

Source: https://gobuffalo.io/documentation/guides/apis

Shows the command for creating a standard Buffalo application, which includes front-end assets and templating by default. This results in a more comprehensive project layout.

```bash
$ buffalo new coke

```

```text
├── .yarn/
├── actions/
│ 	├── app.go
│ 	└── render.go
├── assets/
├── cmd/
│ 	└── app/
│ 		└── main.go
├── config/
├── fixtures/
├── grifts/
├── locales/
├── models/
├── public/
├── templates/
├── .babelrc
├── .buffalo.dev.yml
├── .codeclimate.yml
├── .docketignore
├── .env
├── .gitignore
├── .pnp.cjs
├── .pnp.loader.mjs
├── .yarnrc.yml
├── database.yml
├── Dockerfile
├── go.mod
├── go.sum
├── inflections.json
├── package.json
├── postcss.config.js
├── README.md
├── webpack.config.js
└── yarn.lock

```

--------------------------------

### Install Pop Package

Source: https://gobuffalo.io/documentation/database/pop

Installs the Pop package and its dependencies using the Go toolchain. Pop is Buffalo's default database package, wrapping sqlx for ORM-like functionality.

```go
go get github.com/gobuffalo/pop/...
```

--------------------------------

### Render HTML with Layout

Source: https://gobuffalo.io/documentation/frontend-layer/layouts

An example Go function demonstrating how to render an HTML template using the configured render engine. The `r.HTML("hello.html")` call tells the engine to render 'hello.html' and apply the default layout.

```go
func Hello(c buffalo.Context) error {
  return c.Render(http.StatusOK, r.HTML("hello.html"))
}
```

--------------------------------

### Update Buffalo Installation

Source: https://gobuffalo.io/documentation/troubleshooting

Fixes issues with `buffalo new` by ensuring the latest Buffalo installation is present. This command updates the Buffalo binary and its dependencies. Requires a working Go toolchain.

```go
$ go get -u -v github.com/gobuffalo/buffalo/buffalo
```

--------------------------------

### Database Configuration Options

Source: https://gobuffalo.io/documentation/database/configuration

Provides a detailed breakdown of the available configuration parameters for establishing database connections in Pop, including dialect, host, user, password, port, and driver-specific options.

```APIDOC
Available Options:

- database:
    The name of the database to use.

- dialect:
    The database dialect to use with the connection. Accepted values:
    * MySQL driver: "mysql"
    * PostgreSQL driver: "postgres", "postgresql" or "pg"
    * Cockroach driver: "cockroach", "cockroachdb" or "crdb"
    * SQLite driver: "sqlite" or "sqlite3"

- driver:
    Since 4.11.2
    Use this option to customize the database driver and override the default one used by Pop.
    Default SQL drivers:
    * MySQL: github.com/go-sql-driver/mysql
    * PostgreSQL: github.com/lib/pq
    * Cockroach DB: github.com/cockroachdb/cockroach-go/crdb
    * SQLite: github.com/mattn/go-sqlite3

- encoding:
    Since 4.6.0
    Supported by the mysql dialect. Used for database creation and connection string collation.
    Default: utf8mb4_general_ci
    Example:
    development:
      dialect: mysql
      options:
        encoding: "utf8_general_ci"

- host:
    The database host address to connect to.

- password:
    The password for the user to connect to the database.

- port:
    The database host port.
    Defaults:
    | Driver     | Port |
    |------------|------|
    | PostgreSQL | 5432 |
    | MySQL      | 3306 |
    | Cockroach  | 26257|

- user:
    The user to use to connect to the database.
```

--------------------------------

### Create Standard Application

Source: https://gobuffalo.io/documentation/guides/apis

Command to generate a new standard Buffalo web project. This includes configurations for serving HTML, static files, and typical web application middleware.

```shell
$ buffalo new coke
```

--------------------------------

### Migrating from Dep to Go Modules

Source: https://gobuffalo.io/documentation/guides/gomods

Explains how to use the `go mod init` tool to create a new `go.mod` file by reading existing `Gopkg.toml` files, facilitating migration from the deprecated dep dependency management system.

```bash
go mod init
```

--------------------------------

### Install buffalo-goth Plugin

Source: https://gobuffalo.io/documentation/guides/goth

Installs the buffalo-goth plugin, which provides native support for Goth authentication packages in Buffalo applications. This is the recommended way to integrate third-party authentication since Buffalo v0.9.4.

```shell
$ buffalo plugins install github.com/gobuffalo/buffalo-goth
```

--------------------------------

### Install Buffalo on MacOS

Source: https://gobuffalo.io/documentation/getting_started/installation

Installs the Buffalo CLI tool on MacOS systems using curl to download the archive and tar to extract it. The binary is then moved to /usr/local/bin for system-wide access, requiring sudo privileges.

```Shell
$ curl -OL https://github.com/gobuffalo/cli/releases/download//buffalo__Darwin_x86_64.tar.gz
$ tar -xvzf buffalo__Darwin_x86_64.tar.gz
$ sudo mv buffalo /usr/local/bin/buffalo
```

--------------------------------

### Setup Buffalo App and Middleware in Go

Source: https://gobuffalo.io/documentation/guides/auth

Defines the main Buffalo application instance, configures essential middleware such as SSL redirection, parameter logging, CSRF protection, database transactions, and internationalization. It also registers core routes for the application.

```go
// actions/app.go
package actions

import (
  "github.com/gobuffalo/buffalo"
  "github.com/gobuffalo/buffalo/middleware"
  "github.com/gobuffalo/buffalo/middleware/ssl"
  "github.com/gobuffalo/envy"
  "github.com/unrolled/secure"

  "coke/models"

  "github.com/gobuffalo/buffalo/middleware/csrf"
  "github.com/gobuffalo/buffalo/middleware/i18n"
  "github.com/gobuffalo/packr"
)

// ENV is used to help switch settings based on where the
// application is being run. Default is "development".
var ENV = envy.Get("GO_ENV", "development")
var app *buffalo.App
var T *i18n.Translator

// App is where all routes and middleware for buffalo
// should be defined. This is the nerve center of your
// application.
func App() *buffalo.App {
  if app == nil {
    app = buffalo.New(buffalo.Options{
      Env:         ENV,
      SessionName: "_coke_session",
    })
    // Automatically redirect to SSL
    app.Use(forceSSL())

    if ENV == "development" {
      app.Use(middleware.ParameterLogger)
    }

    // Protect against CSRF attacks. https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)
    // Remove to disable this.
    app.Use(csrf.New)

    // Wraps each request in a transaction.
    //  c.Value("tx").(*pop.PopTransaction)
    // Remove to disable this.
    app.Use(middleware.PopTransaction(models.DB))

    // Setup and use translations:
    app.Use(translations())

    app.GET("/", HomeHandler)

    app.Use(SetCurrentUser)
    app.Use(Authorize)
    app.GET("/users/new", UsersNew)
    app.POST("/users", UsersCreate)
    app.GET("/signin", AuthNew)
    app.POST("/signin", AuthCreate)
    app.DELETE("/signout", AuthDestroy)
    app.Middleware.Skip(Authorize, HomeHandler, UsersNew, UsersCreate, AuthNew, AuthCreate)
    app.ServeFiles("/", assetsBox) // serve files from the public directory
  }

  return app
}

// translations will load locale files, set up the translator `actions.T`,
// and will return a middleware to use to load the correct locale for each
// request.
// for more information: https://gobuffalo.io/en/docs/localization
func translations() buffalo.MiddlewareFunc {
  var err error
  if T, err = i18n.New(packr.NewBox("../locales"), "en-US"); err != nil {
    app.Stop(err)
  }
  return T.Middleware()
}

// forceSSL will return a middleware that will redirect an incoming request
// if it is not HTTPS. "http://example.com" => "https://example.com".
// This middleware does **not** enable SSL. for your application. To do that
// we recommend using a proxy: https://gobuffalo.io/en/docs/proxy
// for more information: https://github.com/unrolled/secure/
func forceSSL() buffalo.MiddlewareFunc {
  return ssl.ForceSSL(secure.Options{
    SSLRedirect:     ENV == "production",
    SSLProxyHeaders: map[string]string{"X-Forwarded-Proto": "https"},
  })
}

```

--------------------------------

### Buffalo App Setup and Routing

Source: https://gobuffalo.io/documentation/guides/goth

Configures the main Buffalo application, including environment-specific middleware, CSRF protection, database transaction handling, internationalization, static file serving, and defining routes for the home page and authentication endpoints.

```go
package actions

import (
  "github.com/gobuffalo/buffalo"
  "github.com/gobuffalo/buffalo/middleware"
  "github.com/gobuffalo/buffalo/middleware/csrf"
  "github.com/gobuffalo/buffalo/middleware/i18n"

  "github.com/markbates/coke/models"

  "github.com/gobuffalo/envy"
  "github.com/gobuffalo/packr"

  "github.com/markbates/goth/gothic"
)

// ENV is used to help switch settings based on where the
// application is being run. Default is "development".
var ENV = envy.Get("GO_ENV", "development")
var app *buffalo.App
var T *i18n.Translator

// App is where all routes and middleware for buffalo
// should be defined. This is the nerve center of your
// application.
func App() *buffalo.App {
  if app == nil {
    app = buffalo.New(buffalo.Options{
      Env:         ENV,
      SessionName: "_coke_session",
    })

    if ENV == "development" {
      app.Use(middleware.ParameterLogger)
    }
    if ENV != "test" {
      // Protect against CSRF attacks. https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)
      // Remove to disable this.
      app.Use(csrf.Middleware)
    }

    // Wraps each request in a transaction.
    //  c.Value("tx").(*pop.PopTransaction)
    // Remove to disable this.
    app.Use(middleware.PopTransaction(models.DB))

    // Setup and use translations:
    var err error
    if T, err = i18n.New(packr.NewBox("../locales"), "en-US"); err != nil {
      app.Stop(err)
    }
    app.Use(T.Middleware())

    app.GET("/", HomeHandler)

    app.ServeFiles("/assets", packr.NewBox("../public/assets"))
    auth := app.Group("/auth")
    auth.GET("/{provider}", buffalo.WrapHandlerFunc(gothic.BeginAuthHandler))
    auth.GET("/{provider}/callback", AuthCallback)
  }

  return app
}
```

--------------------------------

### Pop Transaction Middleware Setup

Source: https://gobuffalo.io/documentation/database/buffalo-integration

Illustrates the setup of the Pop Transaction Middleware in a Buffalo application's `actions/app.go` file. This middleware wraps HTTP requests in database transactions, logging durations, committing on success (2xx/3xx status codes), and rolling back on errors.

```go
func App() *buffalo.App {
    if app == nil {
        // [...]\n
        app.Use(poptx.PopTransaction(models.DB))

        // [...]\n
        app.GET("/", HomeHandler)
    }

    return app
}

```

--------------------------------

### Localized Views: fr-FR Template

Source: https://gobuffalo.io/documentation/guides/localization

Example of an HTML template suffixed for the 'fr-FR' locale, providing locale-specific content.

```html
<p>This is my fr-FR version.</p>

```

--------------------------------

### Localized Views: en-US Template

Source: https://gobuffalo.io/documentation/guides/localization

Example of an HTML template suffixed for the 'en-US' locale, providing locale-specific content.

```html
<p>This is my en-US version.</p>

```

--------------------------------

### Configure Buffalo App

Source: https://gobuffalo.io/documentation/request_handling/routing

Sets up the core Buffalo application instance with essential options like environment and session name. The configuration is typically done in the actions/app.go file.

```go
app = buffalo.New(buffalo.Options{
    Env:         ENV,
    SessionName: "_coke_session",
  })

```
Tokens:
Raw