gody

package module
v2.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 30, 2020 License: MIT Imports: 4 Imported by: 0

README

gody

Mentioned in Awesome Go GoDoc Go Report Card Build Status Coverage Status GitHub release (latest by date)

Installation
go get github.com/guiferpa/gody/v2
Usage
package main

import (
    "encoding/json"
    "fmt"
    "net/http"

    gody "github.com/guiferpa/gody/v2"
    "github.com/guiferpa/gody/v2/rule"
) 

type RequestBody struct {
    Name string `json:"name" validate:"not_empty"`
    Age  int    `json:"age" validate:"min=21"`
}

func HTTPHandler(vtr *gody.Validator) http.HandlerFunc {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var body RequestBody
        if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
	    ...
    	}
	defer r.Body.Close()

	if validated, err := vtr.Validate(body); err != nil {
	    ...                                                                                
	}
    })
}

func main() {
    validator := gody.NewValidator()

    rules := []gody.Rule{rule.NotEmpty, rule.Min}
    validator.AddRules(rules...)

    port := ":3000"
    http.ListenAndServe(port, HTTPHandler(validator))
}
Others ways for validation

There are others ways to valid a struct, take a look on functions below:

  • RawValidate - It's a function that make validate with no rule, it's necessary put the struct for validation, some rule(s) and tag name.
gody.RawValidate(interface{}, string, []gody.Rule) (bool, error)
  • Validate - It's a function that make validate with no rule, it's necessary put the struct for validation and some rule(s).
gody.Validate(interface{}, []gody.Rule) (bool, error)
  • RawDefaultValidate - It's a function that already have built-in rules configured, it's necessary put the struct for validation, tag name and optional custom rule(s).
gody.RawDefaultValidate(interface{}, string, []gody.Rule) (bool, error)
  • DefaultValidate - It's a function that already have built-in rules configured, it's necessary put the struct for validation and optional custom rule(s).
gody.DefaultValidate(interface{}, []gody.Rule) (bool, error)
Contribution policies
  1. At this time the only policy is don't create a Pull Request directly, it's necessary some discussions for some implementation then open an issue before to dicussion anything about the project.

Documentation

Index

Constants

View Source
const DefaultTagName = "validate"

Variables

This section is empty.

Functions

func DefaultValidate

func DefaultValidate(b interface{}, customRules []Rule) (bool, error)

func RawDefaultValidate

func RawDefaultValidate(b interface{}, tn string, customRules []Rule) (bool, error)

func RawValidate

func RawValidate(b interface{}, tn string, rules []Rule) (bool, error)

func Validate

func Validate(b interface{}, rules []Rule) (bool, error)

Validate contains the entrypoint to validation of struct input

func ValidateFields

func ValidateFields(fields []Field, rules []Rule) (bool, error)

Types

type ErrDuplicatedRule

type ErrDuplicatedRule struct {
	RuleDuplicated Rule
}

func (*ErrDuplicatedRule) Error

func (err *ErrDuplicatedRule) Error() string

type ErrEmptyTagName

type ErrEmptyTagName struct{}

func (*ErrEmptyTagName) Error

func (e *ErrEmptyTagName) Error() string

type ErrInvalidBody

type ErrInvalidBody struct {
	Kind reflect.Kind
}

ErrInvalidBody represents all invalid body report

func (*ErrInvalidBody) Error

func (e *ErrInvalidBody) Error() string

type ErrInvalidTag

type ErrInvalidTag struct {
	Format string
}

ErrInvalidTag represents all invalid tag report

func (*ErrInvalidTag) Error

func (e *ErrInvalidTag) Error() string

type Field

type Field struct {
	Name  string
	Value string
	Tags  map[string]string
}

Field is a struct to represents the domain about a field inner gody lib

func RawSerialize

func RawSerialize(tn string, b interface{}) ([]Field, error)

RawSerialize is a func to serialize/parse all content about the struct input

func Serialize

func Serialize(b interface{}) ([]Field, error)

type Rule

type Rule interface {
	Name() string
	Validate(name, value, param string) (bool, error)
}

Rule is a interface with the contract to implement a any rule

type Validator

type Validator struct {
	// contains filtered or unexported fields
}

func NewValidator

func NewValidator() *Validator

func (*Validator) AddRules

func (v *Validator) AddRules(rs ...Rule) error

func (*Validator) SetTagName

func (v *Validator) SetTagName(tn string) error

func (*Validator) Validate

func (v *Validator) Validate(b interface{}) (bool, error)

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL