tags

README

tags

created by Austin Poor

A micro-helper-library for working with Go struct tags.

Installation

Install with go get:

go get github.com/a-poor/tags

Example

Here's a quick example of working with the tags library.

// Define a struct that we'll be getting the tags from
user := struct {
    ID      int    `app:"user_id"`
    Name    string `app:",omitempty"`
    Email   string `app:"user_email,omitempty"`
    NotMe   bool
    ImEmpty bool `app:""`
}{}

// Parse the struct's tags
fields := tags.ParseStructTags("app", user)

// Print out the results as JSON
data, _ := json.MarshalIndent(fields, "", "  ")
fmt.Println(string(data))
// Output: {
//   "Email": [
//     "user_email",
//     "omitempty"
//   ],
//   "ID": [
//     "user_id"
//   ],
//   "ImEmpty": [
//     ""
//   ],
//   "Name": [
//     "",
//     "omitempty"
//   ]
// }

Usage

The tags library is very small. At least for now.

There's only one struct, TagParser, which has one field, TagName, and one method, Parse.

Say, for example, we have a struct that looks like this:

type User struct {
    ID       int     `myTag:"user_id"`
    Name     string  `myTag:"name" otherTag"abc123"`
    Balance  float32 `myTag:"balance,omitempty"`
    IsActive bool    `myTag:",hello"`
}

If we wanted to get the struct tag values for myTag, we could create a new TagParser like this:

tp := tags.TagParser{TagName: "myTag"}

and then parse the struct's tags like this:

u := User{} // Create a blank user
ut := tp.Parse(u)

ut is of the type map[string][]string, where each of the map's keys are fields of the struct (with tags), and the map's values are arrays of tag values corresponding to the chosen tag, split on commas.

In our example, we would have the following result (formatted as JSON):

{
  "Balance": [
    "balance",
    "omitempty"
  ],
  "ID": [
    "user_id"
  ],
  "IsActive": [
    "",
    "hello"
  ],
  "Name": [
    "name"
  ]
}

To Do

• Should untagged fields appear in the returned result?
• Add more error checks
  • ie Catch panics caused by tags and return them rather than letting the panic propagate
  • Check that the passed value is a struct (not a basic type)
• Be able to pass a pointer to a struct (without panicing)
• Fill a struct with struct tag values?
  • ie struct would have fields name, omitempty, etc. and would be filled by position or value (like flags).

License

MIT

Contributing

Go ahead and create an issue or submit a pull request! I'd love to hear from you.

Documentation

Index

• func ParseStructTags(tagName string, d interface{}) map[string][]string
• type TagParser
  • func (p TagParser) Parse(d interface{}) map[string][]string

Examples

• TagParser

Functions

func ParseStructTags

func ParseStructTags(tagName string, d interface{}) map[string][]string

ParseStructTags parses a struct's tags and returns a map of the struct's fields to an array of the tag values.

This is a convenience function that creates a new `TagParse` instance and calles its `Parse` method.

Types

type TagParser

type TagParser struct {
	TagName string // They key to look for in the struct tags
}

TagParser is a struct used for parsing struct tags with the key `TagName`.

Example

package main

import (
	"encoding/json"
	"fmt"

	"github.com/a-poor/tags"
)

func main() {
	// Define a struct that we'll be getting the tags from
	user := struct {
		ID      int    `app:"user_id"`
		Name    string `app:",omitempty"`
		Email   string `app:"user_email,omitempty"`
		NotMe   bool
		ImEmpty bool `app:""`
	}{}

	// Parse the struct's tags
	fields := tags.ParseStructTags("app", user)

	// Print out the results as JSON
	data, _ := json.MarshalIndent(fields, "", "  ")
	fmt.Println(string(data))
}

Output:

{
  "Email": [
    "user_email",
    "omitempty"
  ],
  "ID": [
    "user_id"
  ],
  "ImEmpty": [
    ""
  ],
  "Name": [
    "",
    "omitempty"
  ]
}

func (TagParser) Parse

func (p TagParser) Parse(d interface{}) map[string][]string

Parse parses the struct tags of of the given struct and returns a map from the struct's fields to an array of the tag values.

Note: `d` is expected to be passed by value, not by reference.