vala

A simple, extensible, library to make argument validation in Go palatable.

Instead of this:

func BoringValidation(a, b, c, d, e, f, g MyType) {
  if (a == nil)
    panic("a is nil")
  if (b == nil)
    panic("b is nil")
  if (c == nil)
    panic("c is nil")
  if (d == nil)
    panic("d is nil")
  if (e == nil)
    panic("e is nil")
  if (f == nil)
    panic("f is nil")
  if (g == nil)
    panic("g is nil")
}

Do this:

func ClearValidation(a, b, c, d, e, f, g MyType) {
  BeginValidation().Validate(
    IsNotNil(a, "a"),
    IsNotNil(b, "b"),
    IsNotNil(c, "c"),
    IsNotNil(d, "d"),
    IsNotNil(e, "e"),
    IsNotNil(f, "f"),
    IsNotNil(g, "g"),
  ).CheckAndPanic() // All values will get checked before an error is thrown!
}

Instead of this:

func BoringValidation(a, b, c, d, e, f, g MyType) error {
  if (a == nil)
    return fmt.Errorf("a is nil")
  if (b == nil)
    return fmt.Errorf("b is nil")
  if (c == nil)
    return fmt.Errorf("c is nil")
  if (d == nil)
    return fmt.Errorf("d is nil")
  if (e == nil)
    return fmt.Errorf("e is nil")
  if (f == nil)
    return fmt.Errorf("f is nil")
  if (g == nil)
    return fmt.Errorf("g is nil")
}

Do this:

func ClearValidation(a, b, c, d, e, f, g MyType) (err error) {
  defer func() { recover() }
  BeginValidation().Validate(
    IsNotNil(a, "a"),
    IsNotNil(b, "b"),
    IsNotNil(c, "c"),
    IsNotNil(d, "d"),
    IsNotNil(e, "e"),
    IsNotNil(f, "f"),
    IsNotNil(g, "g"),
  ).CheckSetErrorAndPanic(&err) // Return error will get set, and the function will return.

  // ...

  VeryExpensiveFunction(c, d)
}

Tier your validation:

func ClearValidation(a, b, c MyType) (err error) {
  err = BeginValidation().Validate(
    IsNotNil(a, "a"),
    IsNotNil(b, "b"),
    IsNotNil(c, "c"),
  ).CheckAndPanic().Validate( // Panic will occur here if a, b, or c are nil.
    HasLen(a.Items, 50, "a.Items"),
    GreaterThan(b.UserCount, 0, "b.UserCount"),
    Equals(c.Name, "Vala", "c.name"),
    Not(Equals(c.FriendlyName, "Foo", "c.FriendlyName")),
  ).Check()

  if err != nil {
  	return err
  }

  // ...

  VeryExpensiveFunction(c, d)
}

Extend with your own validators for readability. Note that an error should always be returned so that the Not function can return a message if it passes. Unlike idiomatic Go, use the boolean to check for success.

func ReportFitsRepository(report *Report, repository *Repository) Checker {
	return func() (passes bool, err error) {

		err = fmt.Errof("A %s report does not belong in a %s repository.", report.Type, repository.Type)
		passes = (repository.Type == report.Type)
		return passes, err
	}
}

func AuthorCanUpload(authorName string, repository *Repository) Checker {
	return func() (passes bool, err error) {
        err = fmt.Errof("%s does not have access to this repository.", authorName)
		passes = !repository.AuthorCanUpload(authorName)
		return passes, err
	}
}

func AuthorIsCollaborator(authorName string, report *Report) Checker {
	return func() (passes bool, err error) {

        err = fmt.Errorf("The given author was not one of the collaborators for this report.")
		for _, collaboratorName := range report.Collaborators() {
			if collaboratorName == authorName {
				passes = true
				break
			}
		}

        return passes, err
	}
}

func HandleReport(authorName string, report *Report, repository *Repository) {

	BeginValidation().Validate(
    	AuthorIsCollaborator(authorName, report),
		AuthorCanUpload(authorName, repository),
		ReportFitsRepository(report, repository),
	).CheckAndPanic()
}