github.com/mitchellh/reflectwalk v1.0.2

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:b0264a3a91d3e0eb02a1231893d75d5b1cf212146d6c700148a5a8a126d74b6c","contract":["reflectwalk.Walk traverses struct fields and invokes StructField callback with field metadata","reflectwalk.Walk traverses primitive values and invokes Primitive callback","reflectwalk.Walk traverses slice elements and invokes Slice and SliceElem callbacks","reflectwalk.Walk skips nested struct field values when StructField returns SkipEntry"],"goal":"verify pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2","kind":"HOW","packages":["pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2"],"schemaVersion":1},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2"],"schemaVersion":1,"subject":"pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2","verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/mitchellh/reflectwalk v1.0.2

github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=

package main

import (
	"fmt"
	"reflect"

	"github.com/mitchellh/reflectwalk"
)

type fieldCollector struct {
	fields []string
}

func (w *fieldCollector) Struct(v reflect.Value) error {
	return nil
}

func (w *fieldCollector) StructField(f reflect.StructField, v reflect.Value) error {
	w.fields = append(w.fields, f.Name)
	return nil
}

type ServerConfig struct {
	Host string
	Port int
}

func main() {
	cfg := ServerConfig{
		Host: "localhost",
		Port: 8080,
	}

	walker := &fieldCollector{}
	if err := reflectwalk.Walk(cfg, walker); err != nil {
		fmt.Printf("Walk failed: %v\n", err)
		return
	}

	fmt.Printf("Walked fields: %v\n", walker.fields)
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/mitchellh/reflectwalk@v1.0.2"
  ]
}

package main

import (
	"fmt"
	"os"
	"reflect"

	"github.com/mitchellh/reflectwalk"
)

func main() {
	if err := runContract(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract verification failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All reflectwalk contract assertions passed successfully.")
}

type testStructWalker struct {
	structCount int
	fieldNames  []string
}

func (w *testStructWalker) Struct(v reflect.Value) error {
	w.structCount++
	return nil
}

func (w *testStructWalker) StructField(f reflect.StructField, v reflect.Value) error {
	w.fieldNames = append(w.fieldNames, f.Name)
	return nil
}

type testPrimitiveWalker struct {
	primitives []interface{}
}

func (w *testPrimitiveWalker) Primitive(v reflect.Value) error {
	w.primitives = append(w.primitives, v.Interface())
	return nil
}

type testSliceWalker struct {
	sliceCount int
	elements   []interface{}
}

func (w *testSliceWalker) Slice(v reflect.Value) error {
	w.sliceCount++
	return nil
}

func (w *testSliceWalker) SliceElem(idx int, v reflect.Value) error {
	w.elements = append(w.elements, v.Interface())
	return nil
}

type testSkipWalker struct {
	visitedFields []string
	primitives    []interface{}
}

func (w *testSkipWalker) Struct(v reflect.Value) error {
	return nil
}

func (w *testSkipWalker) StructField(f reflect.StructField, v reflect.Value) error {
	w.visitedFields = append(w.visitedFields, f.Name)
	if f.Name == "Secret" {
		return reflectwalk.SkipEntry
	}
	return nil
}

func (w *testSkipWalker) Primitive(v reflect.Value) error {
	w.primitives = append(w.primitives, v.Interface())
	return nil
}

type SampleData struct {
	Name    string
	Age     int
	Tags    []string
	Secret  string
}

func runContract() error {
	data := SampleData{
		Name:   "example-user",
		Age:    30,
		Tags:   []string{"admin", "developer"},
		Secret: "do-not-walk-this",
	}

	// Assertion 1: reflectwalk.Walk traverses struct fields and invokes StructField callback with field metadata
	structWalker := &testStructWalker{}
	if err := reflectwalk.Walk(data, structWalker); err != nil {
		return fmt.Errorf("StructWalker failed: %w", err)
	}
	if structWalker.structCount == 0 {
		return fmt.Errorf("expected structCount > 0, got %d", structWalker.structCount)
	}
	expectedFields := map[string]bool{"Name": false, "Age": false, "Tags": false, "Secret": false}
	for _, f := range structWalker.fieldNames {
		expectedFields[f] = true
	}
	for name, found := range expectedFields {
		if !found {
			return fmt.Errorf("expected StructField callback for field %q", name)
		}
	}

	// Assertion 2: reflectwalk.Walk traverses primitive values and invokes Primitive callback
	primitiveWalker := &testPrimitiveWalker{}
	simple := struct {
		Title string
		Count int
		Valid bool
	}{
		Title: "sample",
		Count: 42,
		Valid: true,
	}
	if err := reflectwalk.Walk(simple, primitiveWalker); err != nil {
		return fmt.Errorf("PrimitiveWalker failed: %w", err)
	}
	hasString := false
	hasInt := false
	hasBool := false
	for _, p := range primitiveWalker.primitives {
		switch v := p.(type) {
		case string:
			if v == "sample" {
				hasString = true
			}
		case int:
			if v == 42 {
				hasInt = true
			}
		case bool:
			if v == true {
				hasBool = true
			}
		}
	}
	if !hasString || !hasInt || !hasBool {
		return fmt.Errorf("expected primitives 'sample', 42, true; got: %v", primitiveWalker.primitives)
	}

	// Assertion 3: reflectwalk.Walk traverses slice elements and invokes Slice and SliceElem callbacks
	sliceWalker := &testSliceWalker{}
	sliceData := []string{"first", "second"}
	if err := reflectwalk.Walk(sliceData, sliceWalker); err != nil {
		return fmt.Errorf("SliceWalker failed: %w", err)
	}
	if sliceWalker.sliceCount != 1 {
		return fmt.Errorf("expected sliceCount 1, got %d", sliceWalker.sliceCount)
	}
	if len(sliceWalker.elements) != 2 || sliceWalker.elements[0] != "first" || sliceWalker.elements[1] != "second" {
		return fmt.Errorf("unexpected slice elements: %v", sliceWalker.elements)
	}

	// Assertion 4: reflectwalk.Walk skips nested struct field values when StructField returns SkipEntry
	skipWalker := &testSkipWalker{}
	if err := reflectwalk.Walk(data, skipWalker); err != nil {
		return fmt.Errorf("SkipWalker failed: %w", err)
	}
	for _, p := range skipWalker.primitives {
		if p == "do-not-walk-this" {
			return fmt.Errorf("expected field 'Secret' value to be skipped, but found in primitives: %v", p)
		}
	}

	return nil
}