forms

README

gothite/forms

Form handling and data validation for Go

Installation

go get github.com/gothite/forms

Usage

package main

import (
	"errors"
	"fmt"

	"github.com/gothite/forms"
	"github.com/gothite/forms/codes"
	"github.com/gothite/forms/fields"
	"github.com/gothite/forms/validators"
)

type LoginFormData struct {
	Email    string `forms:"email"`
	Password string `forms:"password"`
}

func (data *LoginFormData) Clean(form *forms.Form) error {
	// Check data
	return nil
}

// LoginForm handles user login.
var LoginForm = forms.NewForm(
	map[uint]error{codes.Invalid: errors.New("Please, check data.")},
	&fields.Email{
		Name:   "email",
		Errors: map[uint]string{codes.Invalid: "Please, set a valid email."},
	},
	&fields.String{
		Name: "password",
		Validators: []validators.StringValidator{
			validators.StringMinLength(5),
		},
	},
)

func main() {
	var form LoginFormData
	data := map[string]interface{}{"email": "hello@binlockme", "password": "pass"}

	if err, errors := LoginForm.Validate(&form, data); err != nil {
		fmt.Printf("Form error: %v\n", err)

		for field, err := range errors {
			fmt.Printf("%v error: %v\n", field, err)
		}
	} else {
		fmt.Printf("Email: %s\n", form.Email)
		fmt.Printf("Password: %s\n", form.Password)
	}
}

Documentation

Index

• Variables
• func Map(target FormData, data map[string]interface{})
• type Error
  • func (err *Error) Error() string
• type Form
  • func NewForm(errors map[uint]error, fields ...fields.Field) *Form
  • func (form *Form) GetError(code uint, errors map[string]error) error
  • func (form *Form) Validate(target FormData, data map[string]interface{}) (error, map[string]error)
  • func (form *Form) ValidateForm(target FormData, payload url.Values) (error, map[string]error)
  • func (form *Form) ValidateJSON(target FormData, reader io.Reader) (error, map[string]error)
• type FormData

Variables

var Errors = map[uint]string{
	codes.Unknown:     "Unknown error.",
	codes.Invalid:     "Ensure that all values are valid.",
	codes.InvalidJSON: "Unable to parse JSON.",
}

Functions

func Map

func Map(target FormData, data map[string]interface{})

Types

type Error

type Error struct {
	Code    uint             `json:"code"`
	Message string           `json:"message"`
	Errors  map[string]error `json:"errors"`
}

func (*Error) Error

func (err *Error) Error() string

type Form

type Form struct {
	Fields []fields.Field
	Errors map[uint]error
}

Form describes a form validator.

func NewForm

func NewForm(errors map[uint]error, fields ...fields.Field) *Form

NewForm returns Form instance with passed fields.

func (*Form) GetError

func (form *Form) GetError(code uint, errors map[string]error) error

func (*Form) Validate

func (form *Form) Validate(target FormData, data map[string]interface{}) (error, map[string]error)

Validate validates input data and map it to target.

func (*Form) ValidateForm

func (form *Form) ValidateForm(target FormData, payload url.Values) (error, map[string]error)

func (*Form) ValidateJSON

func (form *Form) ValidateJSON(target FormData, reader io.Reader) (error, map[string]error)

type FormData

type FormData interface {
	Clean(form *Form) error
}