Categorygithub.com/jacobsoderblom/buffalo
modulepackage
0.11.0
Repository: https://github.com/jacobsoderblom/buffalo.git
Documentation: pkg.go.dev
Overview
Versions
1
Dependencies
46
Dependents
0
Files
1.8k SLOC

# README

GoDoc Build Status Windows Build status Go Report Card Open Source Helpers

Buffalo

Buffalo is a Go web development eco-system. Designed to make the life of a Go web developer easier.

Buffalo starts by generating a web project for you that already has everything from front-end (JavaScript, SCSS, etc...) to back-end (database, routing, etc...) already hooked up and ready to run. From there it provides easy APIs to build your web application quickly in Go.

Buffalo isn't just a framework, it's a holistic web development environment and project structure that lets developers get straight to the business of, well, building their business.

I :heart: web dev in go again - Brian Ketelsen

Documentation

Please visit http://gobuffalo.io for the latest documentation, examples, and more.

Installation

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

NOTE: Buffalo has a minimum Go dependency of 1.8.1.

Buffalo also depends on:

  • gcc for go-sqlite3 which is a cgo package.
  • node and npm for the asset pipeline.

Generating a new Project

Buffalo aims to make building new web applications in Go as simple as possible, and what could be more simple than a new application generator?

$ buffalo new <name>

That will generate a whole new Buffalo application that is ready to go. It'll even run go get for you to make sure you have all of the necessary dependencies needed to run your application.

To see a list of available flags for the new command, just check out its help.

$ buffalo help new

Running your application

Buffalo is Go "standards" compliant. That means you can just build your binary and run it. It's that simple.

Running your application in Development

One of the downsides to Go development is the lack of code "reloading". This means as you change your code you need to manually stop your application, rebuild it, and then restart it. Buffalo finds this is annoying and wants to make life better for you.

$ buffalo dev

The dev command will watch your .go and .html files by default, rebuild, and restart your binary for you so you don't have to worry about such things. Just run the dev command and start coding.

Testing your application

Just like running your application, Buffalo doesn't stop you from using the standard Go tools for testing. Buffalo does ship with a test command that will run all of your tests while conveniently skipping that pesky old ./vendor directory!

$ buffalo test

Shoulders of Giants

Buffalo would not be possible if not for all of the great projects it depends on. Please see SHOULDERS.md to see a list of them.

Templating

github.com/gobuffalo/plush - This templating package was chosen over the standard Go html/template package for a variety of reasons. The biggest of which is that it is significantly more flexible and easy to work with.

Routing

github.com/gorilla/mux - This router was chosen because of its stability and flexibility. There might be faster routers out there, but this one is definitely the most powerful!

Task Runner (Optional)

github.com/markbates/grift - If you're familiar with Rake tasks from Ruby, you'll be right at home using Grift. This package was chosen to allow for the easy running of simple, and common, tasks that most web applications need. Think things like seeding a database or taking in a CSV file and generating database records. Buffalo ships with an example routes task that prints off the defined routes and the function that handles those requests.

Models/ORM (Optional)

github.com/gobuffalo/pop - Accessing databases is nothing new in web applications. Pop, and its command line tool, Soda, were chosen because they strike a nice balance between simplifying common tasks, being idiomatic, and giving you the flexibility you need to built your app. Pop and Soda share the same core philosphies as Buffalo so they were a natural choice.

Sessions, Cookies, Websockets, and more...

github.com/gorilla - The Gorilla toolkit is a great set of packages designed to improve upon the standard library for a variety of web-related packages. With these high quality packages Buffalo is able to keep its "core" code to a minimum and focus on its goal of glueing them all together to make your life better.

Benchmarks

Oh, yeah, everyone wants benchmarks! What would a web framework be without its benchmarks? Well, guess what? I'm not giving you any! That's right. This is Go! I assure you that it is plenty fast enough for you. If you want benchmarks you can either a) checkout any benchmarks that the GIANTS Buffalo is built upon have published, or b) run your own. I have no interest in playing the benchmark game, and neither should you.

# Packages

No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author

# Functions

Grifts decorates the app with tasks.
MethodOverride is the default implementation for the Options#MethodOverride.
New returns a new instance of App and adds some sane, and useful, defaults.
NewLogger based on the specified log level.
NewOptions returns a new Options instance with sensible defaults.
RequestLoggerFunc is the default implementation of the RequestLogger.
WrapHandler wraps a standard http.Handler and transforms it into a buffalo.Handler.
WrapHandlerFunc wraps a standard http.HandlerFunc and transforms it into a buffalo.Handler.

# Variables

RequestLogger can be be overridden to a user specified function that can be used to log the request.

# Structs

App is where it all happens! It holds on to options, the underlying router, the middleware, and more.
BaseResource fills in the gaps for any Resource interface functions you don't want/need to implement.
Cookies allows you to easily get cookies from the request, and set cookies on the response.
DefaultContext is, as its name implies, a default implementation of the Context interface.
Flash is a struct that helps with the operations over flash messages.
HTTPError a typed error returned by http Handlers and used for choosing error handlers.
MiddlewareStack manages the middleware stack for an App/Group.
Options are used to configure and define how your application should run.
Response implements the http.ResponseWriter interface and allows for the capture of the response status and size to be used for things like logging requests.
RouteInfo provides information about the underlying route that was built.
Session wraps the "github.com/gorilla/sessions" API in something a little cleaner and a bit more useable.

# Interfaces

Context holds on to information as you pass it down through middleware, Handlers, templates, etc..
Logger interface is used throughout Buffalo apps to log a whole manner of things.
ParamValues will most commonly be url.Values, but isn't it great that you set your own? :).
Resource interface allows for the easy mapping of common RESTful actions to a set of paths.

# Type aliases

ErrorHandler interface for handling an error for a specific status code.
ErrorHandlers is used to hold a list of ErrorHandler types that can be used to handle specific status codes.
Handler is the basis for all of Buffalo.
MiddlewareFunc defines the interface for a piece of Buffalo Middleware.
PreWare takes an http.Handler and returns and http.Handler and acts as a pseudo-middleware between the http.Server and a Buffalo application.
RouteHelperFunc represents the function that takes the route and the opts and build the path.
RouteList contains a mapping of the routes defined in the application.