docs: add godoc comments to all exported functions (#195)

Added comprehensive godoc comments following Go conventions to all
exported types, functions, methods, and variables across the codebase.
This improves code documentation and makes the package more maintainable
and easier to understand for contributors.

Files updated:
- internal/models/models.go: 25+ exported items documented
- internal/goparser/goparser.go: 3 exported items documented
- internal/render/render.go: 4 exported items documented
- internal/output/options.go: 2 exported items documented
- internal/output/helpers.go: 1 exported item documented
- internal/output/imports.go: 1 exported item documented
- gotests/process/process.go: 2 exported items documented
- templates/embed.go: 1 exported item documented

All tests pass successfully.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <noreply@anthropic.com>

Author: cweill

gotests/process/process.go

@@ -21,7 +21,7 @@ const (
 	specifyFileMessage = "Please specify a file or directory containing the source"
 )
 
-// Set of options to use when generating tests.
+// Options contains command-line configuration for generating tests.
 type Options struct {
 	OnlyFuncs          string   // Regexp string for filter matches.
 	ExclFuncs          string   // Regexp string for excluding matches.
@@ -40,9 +40,9 @@ type Options struct {
 	UseGoCmp           bool     // Use cmp.Equal (google/go-cmp) instead of reflect.DeepEqual
 }
 
-// Generates tests for the Go files defined in args with the given options.
-// Logs information and errors to out. By default outputs generated tests to
-// out unless specified by opt.
+// Run generates tests for the Go files defined in args with the given options.
+// It logs information and errors to out. By default, it outputs generated tests to
+// out unless WriteOutput is specified in opts.
 func Run(out io.Writer, args []string, opts *Options) {
 	if opts == nil {
 		opts = &Options{}

internal/goparser/goparser.go

@@ -15,18 +15,18 @@ import (
 	"github.com/cweill/gotests/internal/models"
 )
 
-// ErrEmptyFile represents an empty file error.
+// ErrEmptyFile is returned when attempting to parse an empty Go source file.
 var ErrEmptyFile = errors.New("file is empty")
 
-// Result representats a parsed Go file.
+// Result represents a parsed Go file containing the header information and function signatures.
 type Result struct {
 	// The package name and imports of a Go file.
 	Header *models.Header
 	// All the functions and methods in a Go file.
 	Funcs []*models.Function
 }
 
-// Parser can parse Go files.
+// Parser parses Go source files into domain models for test generation.
 type Parser struct {
 	// The importer to resolve packages from import paths.
 	Importer types.Importer

internal/models/models.go

@@ -5,6 +5,7 @@ import (
 	"unicode"
 )
 
+// Expression represents a type expression in Go code, including metadata about pointers, variadic parameters, and writers.
 type Expression struct {
 	Value      string
 	IsStar     bool
@@ -13,6 +14,7 @@ type Expression struct {
 	Underlying string
 }
 
+// String returns the string representation of the expression, including pointer and variadic prefixes.
 func (e *Expression) String() string {
 	value := e.Value
 	if e.IsStar {
@@ -24,20 +26,24 @@ func (e *Expression) String() string {
 	return value
 }
 
+// Field represents a parameter, result, or struct field in a function or method signature.
 type Field struct {
 	Name  string
 	Type  *Expression
 	Index int
 }
 
+// IsWriter returns true if the field is an io.Writer.
 func (f *Field) IsWriter() bool {
 	return f.Type.IsWriter
 }
 
+// IsStruct returns true if the field's underlying type is a struct.
 func (f *Field) IsStruct() bool {
 	return strings.HasPrefix(f.Type.Underlying, "struct")
 }
 
+// IsBasicType returns true if the field is a Go basic type (bool, string, int, etc.).
 func (f *Field) IsBasicType() bool {
 	return isBasicType(f.Type.String()) || isBasicType(f.Type.Underlying)
 }
@@ -53,25 +59,29 @@ func isBasicType(t string) bool {
 	}
 }
 
+// IsNamed returns true if the field has a non-blank name.
 func (f *Field) IsNamed() bool {
 	return f.Name != "" && f.Name != "_"
 }
 
+// ShortName returns a short single-letter name based on the field's type.
 func (f *Field) ShortName() string {
 	return strings.ToLower(string([]rune(f.Type.Value)[0]))
 }
 
+// Receiver represents a method receiver, including its type and struct fields.
 type Receiver struct {
 	*Field
 	Fields []*Field
 }
 
-// TypeParam represents a type parameter in a generic function or type
+// TypeParam represents a type parameter in a generic function or type.
 type TypeParam struct {
 	Name       string // e.g., "T", "K", "V"
 	Constraint string // e.g., "any", "comparable", "int64 | float64"
 }
 
+// Function represents a function or method signature with its parameters, results, and metadata.
 type Function struct {
 	Name         string
 	IsExported   bool
@@ -82,6 +92,7 @@ type Function struct {
 	TypeParams   []*TypeParam // Type parameters for generic functions
 }
 
+// TestParameters returns the function's parameters excluding io.Writer parameters.
 func (f *Function) TestParameters() []*Field {
 	var ps []*Field
 	for _, p := range f.Parameters {
@@ -93,6 +104,7 @@ func (f *Function) TestParameters() []*Field {
 	return ps
 }
 
+// TestResults returns the function's results plus any io.Writer parameters converted to string results.
 func (f *Function) TestResults() []*Field {
 	var ps []*Field
 	ps = append(ps, f.Results...)
@@ -113,18 +125,22 @@ func (f *Function) TestResults() []*Field {
 	return ps
 }
 
+// ReturnsMultiple returns true if the function returns more than one value.
 func (f *Function) ReturnsMultiple() bool {
 	return len(f.Results) > 1
 }
 
+// OnlyReturnsOneValue returns true if the function returns exactly one non-error value.
 func (f *Function) OnlyReturnsOneValue() bool {
 	return len(f.Results) == 1 && !f.ReturnsError
 }
 
+// OnlyReturnsError returns true if the function returns only an error.
 func (f *Function) OnlyReturnsError() bool {
 	return len(f.Results) == 0 && f.ReturnsError
 }
 
+// FullName returns the full name of the function, including the receiver type if it's a method.
 func (f *Function) FullName() string {
 	var r string
 	if f.Receiver != nil {
@@ -133,6 +149,7 @@ func (f *Function) FullName() string {
 	return strings.Title(r) + strings.Title(f.Name)
 }
 
+// TestName returns the name to use for the generated test function.
 func (f *Function) TestName() string {
 	if strings.HasPrefix(f.Name, "Test") {
 		return f.Name
@@ -155,30 +172,36 @@ func (f *Function) TestName() string {
 	return "Test" + f.Name
 }
 
+// IsNaked returns true if the function has no receiver, parameters, or results.
 func (f *Function) IsNaked() bool {
 	return f.Receiver == nil && len(f.Parameters) == 0 && len(f.Results) == 0
 }
 
+// Import represents an import statement with an optional name and the import path.
 type Import struct {
 	Name, Path string
 }
 
+// Header represents the header of a Go file, including package name, imports, and any code between imports and declarations.
 type Header struct {
 	Comments []string
 	Package  string
 	Imports  []*Import
 	Code     []byte
 }
 
+// Path represents a file system path.
 type Path string
 
+// TestPath returns the test file path for the given source file path.
 func (p Path) TestPath() string {
 	if !p.IsTestPath() {
 		return strings.TrimSuffix(string(p), ".go") + "_test.go"
 	}
 	return string(p)
 }
 
+// IsTestPath returns true if the path is a test file path (ends with _test.go).
 func (p Path) IsTestPath() bool {
 	return strings.HasSuffix(string(p), "_test.go")
 }

internal/output/helpers.go

@@ -2,6 +2,7 @@ package output
 
 import "os"
 
+// IsFileExist checks whether a file exists at the given path.
 func IsFileExist(path string) bool {
 	_, err := os.Stat(path)
 	return !os.IsNotExist(err)

internal/output/imports.go

@@ -1,6 +1,7 @@
 package output
 
-// we do not need support for aliases in import for now.
+// importsMap maps template names to their required import paths.
+// We do not need support for aliases in import for now.
 var importsMap = map[string]string{
 	"testify": "github.com/stretchr/testify/assert",
 }

internal/output/options.go

@@ -13,6 +13,7 @@ import (
 	"golang.org/x/tools/imports"
 )
 
+// Options contains configuration for generating and formatting test output.
 type Options struct {
 	PrintInputs    bool
 	Subtests       bool
@@ -27,6 +28,7 @@ type Options struct {
 	render *render.Render
 }
 
+// Process generates formatted test code from the header and function signatures.
 func (o *Options) Process(head *models.Header, funcs []*models.Function) ([]byte, error) {
 	o.render = render.New()
 

internal/render/render.go

@@ -16,10 +16,12 @@ import (
 //go:embed templates/*
 var data embed.FS
 
+// Render manages template rendering for generating test code.
 type Render struct {
 	tmpls *template.Template
 }
 
+// New creates a new Render instance with default templates and helper functions.
 func New() *Render {
 	r := Render{
 		tmpls: template.New("render").Funcs(map[string]interface{}{
@@ -81,6 +83,7 @@ func (r *Render) LoadFromData(templateData [][]byte) {
 	}
 }
 
+// Header renders the file header including package declaration and imports.
 func (r *Render) Header(w io.Writer, h *models.Header) error {
 	if err := r.tmpls.ExecuteTemplate(w, "header", h); err != nil {
 		return err
@@ -89,6 +92,7 @@ func (r *Render) Header(w io.Writer, h *models.Header) error {
 	return err
 }
 
+// TestFunction renders a test function for the given function signature with the specified options.
 func (r *Render) TestFunction(
 	w io.Writer,
 	f *models.Function,

templates/embed.go

@@ -2,5 +2,7 @@ package templates
 
 import "embed"
 
+// FS contains embedded template files for test generation.
+//
 //go:embed test/* testify/*
 var FS embed.FS