parser

README

go-codegen

Docs live at mathbalduino.com.br/go-codegen

---

Matheus Leonel Balduino

Everywhere, under @mathbalduino

• @mathbalduino on GitHub
• @mathbalduino on Instagram
• @mathbalduino on Twitter
• or just mathbalduino.com.br

Documentation

Index

• Constants
• type Config
• type Focus
  • func FocusFilePath(filePath string) *Focus
  • func FocusPackagePath(packagePath string) *Focus
  • func FocusTypeName(typeName string) *Focus
  • func MergeFocus(f1 *Focus, f2 *Focus) *Focus
• type GoParser
  • func NewGoParser(pattern string, config Config) (*GoParser, error)
  • func (p *GoParser) IterateInterfaces(callback InterfacesIterator, optionalLogger ...LoggerCLI) error
  • func (p *GoParser) IterateStructs(callback StructsIterator, optionalLogger ...LoggerCLI) error
• type InterfacesIterator
• type LoggerCLI
• type StructsIterator

Constants

const (
	// LogTrace is a flag that if used will enable
	// Trace logs
	LogTrace = logger.LvlTrace

	// LogDebug is a flag that if used will enable
	// Debug logs
	LogDebug = logger.LvlDebug

	// LogInfo is a flag that if used will enable
	// Info logs
	LogInfo = logger.LvlInfo

	// LogWarn is a flag that if used will enable
	// Warn logs
	LogWarn = logger.LvlWarn

	// LogError is a flag that if used will enable
	// Error logs
	LogError = logger.LvlError

	// LogFatal is a flag that if used will enable
	// Fatal logs
	LogFatal = logger.LvlFatal

	// LogJSON set the logs to be parsed
	// to JSON before printing it to the
	// stdout (one per line)
	LogJSON = uint64(1 << 6)
)

Types

type Config

type Config struct {
	// Tests (from packages.Config) if set, the
	// loader includes not just the packages matching
	// a particular pattern but also any related test
	// packages, including test-only variants of the
	// package and the test executable.
	//
	// For example, when using the go command, loading
	// "fmt" with Tests=true returns four packages, with
	// IDs "fmt" (the standard package), "fmt [fmt.test]"
	// (the package as compiled for the test), "fmt_test"
	// (the test functions from source files in package fmt_test),
	// and "fmt.test" (the test binary).
	//
	// In build systems with explicit names for tests,
	// setting Tests may have no effect.
	Tests bool

	// Dir (from packages.Config) is the directory
	// in which to run the build system's query tool
	// that provides information about the packages.
	//
	// If Dir is empty, the tool is run in the current
	// directory
	Dir string

	// Env (from packages.Config) is the environment
	// to use when invoking the build system's query
	// tool.
	//
	// If Env is nil, the current environment is used.
	// As in os/exec's Cmd, only the last value in the
	// slice for each environment key is used. To specify
	// the setting of only a few variables, append to the
	// current environment, as in:
	// 		opt.Env = append(os.Environ(), "GOOS=plan9", "GOARCH=386")
	Env []string

	// Fset (from packages.Config) provides source
	// position information for syntax trees and
	// types.
	//
	// If Fset is nil, go-codegen will create a new
	// fileset.
	Fset *token.FileSet

	// BuildFlags (from packages.Config) is a list of
	// command-line flags to be passed through to the
	// build system's query tool.
	BuildFlags []string

	// Focus sets the typename/filename/pkgname/etc that
	// the parser should focus.
	//
	// Note that if you set the focus to be some pkg, the
	// filenames, typenames, etc, will continue to be used.
	// Only other pkgs will be ignored (the same for filenames,
	// typenames, etc)
	Focus *Focus

	// Logger is an instance of the LoggerCLI, already created
	// by the lib user.
	//
	// Note that by using this field, the value of the LogFlags
	// field will be ignored
	Logger LoggerCLI

	// LogFlags controls the logging configuration of the parser.
	// It can be set using the constants LogTrace, LogDebug, LogJSON,
	// etc. If the Logger field is set, this field will be ignored.
	//
	// Note that you can use a bitwise-AND operator to combine
	// multiple flags
	LogFlags uint64
}

Config holds some information about the parser behaviour.

Some fields of the packages.Config struct may appear inside this Config struct, exposing them to client customization (others hidden)

type Focus

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

Focus tells to the parser what it needs to focus on

func FocusFilePath

func FocusFilePath(filePath string) *Focus

FocusFilePath will tell the parser to look for a specific file, based on it's ABSOLUTE path.

The given string will be directly forwarded to a regexp.MatchString call, so it should represent a go regular expression.

func FocusPackagePath

func FocusPackagePath(packagePath string) *Focus

FocusPackagePath will tell the parser to look for a specific package.

The given string will be directly forwarded to a regexp.MatchString call, so it should represent a go regular expression.

Note that the packagePath argument refers to the import path to the target package, not the package name

func FocusTypeName

func FocusTypeName(typeName string) *Focus

FocusTypeName will tell the parser to look for a specific GO typename.

The given string will be directly forwarded to a regexp.MatchString call, so it should represent a go regular expression.

func MergeFocus

func MergeFocus(f1 *Focus, f2 *Focus) *Focus

type GoParser

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

GoParser is a type that can parse GO source code and iterate over the parsed code

func NewGoParser

func NewGoParser(pattern string, config Config) (*GoParser, error)

NewGoParser creates a new parser for GO source files

The pattern argument will be forwarded directly to the packages.Load function. Take a look at the docs:

Load passes most patterns directly to the underlying build tool,
but all patterns with the prefix "query=", where query is a non-empty
string of letters from [a-z], are reserved and may be interpreted
as query operators

Two query operators are currently supported: "file" and "pattern"

The query "file=path/to/file.go" matches the package or packages
enclosing the Go source file path/to/file.go. For example
"file=~/go/src/fmt/print.go" might return the packages "fmt" and
"fmt [fmt.test]"

The query "pattern=string" causes "string" to be passed directly to
the underlying build tool. In most cases this is unnecessary, but an
application can use Load("pattern=" + x) as an escaping mechanism to
ensure that x is not interpreted as a query operator if it contains
'='

All other query operators are reserved for future use and currently
cause Load to report an error

 Note that one pattern can match multiple packages and that a package
 might be matched by multiple patterns: in general it is not possible
 to determine which packages correspond to which patterns.

func (*GoParser) IterateInterfaces

func (p *GoParser) IterateInterfaces(callback InterfacesIterator, optionalLogger ...LoggerCLI) error

IterateInterfaces will iterate only over the interfaces that are defined inside the parsed go code

func (*GoParser) IterateStructs

func (p *GoParser) IterateStructs(callback StructsIterator, optionalLogger ...LoggerCLI) error

IterateStructs will iterate only over the structs that are defined inside the parsed go code

type InterfacesIterator

type InterfacesIterator = func(type_ *types.TypeName, logger LoggerCLI) error

type LoggerCLI

type LoggerCLI = loggerCLI.LoggerCLI

type StructsIterator

type StructsIterator = func(type_ *types.TypeName, logger LoggerCLI) error