github.com/mitchellh/copystructure v1.0.0: Copiers

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 github.com/mitchellh/copystructure.Copiers in pkg:golang/github.com/mitchellh/copystructure@v1.0.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/mitchellh/copystructure@v1.0.0
Demonstrate these symbols/APIs:
  - github.com/mitchellh/copystructure.Copiers

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:27e30176516081dc28890db5ca176c76ab54b5e8f4521c6ba399ef18a862c5a6","contract":["copystructure.Copiers contains predefined type copiers including time.Time","copystructure.Copiers map registers custom CopierFunc for struct types to override standard deep copy","copystructure.Copy executes custom CopierFunc registered in copystructure.Copiers for nested structs","copystructure.Copiers function returning an error propagates that error out of copystructure.Copy"],"goal":"verify github.com/mitchellh/copystructure.Copiers in pkg:golang/github.com/mitchellh/copystructure@v1.0.0","kind":"HOW","packages":["pkg:golang/github.com/mitchellh/copystructure@v1.0.0"],"schemaVersion":1,"symbols":["github.com/mitchellh/copystructure.Copiers"]},"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/copystructure@v1.0.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/mitchellh/copystructure@v1.0.0","symbols":["github.com/mitchellh/copystructure.Copiers"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/mitchellh/copystructure v1.0.0

require github.com/mitchellh/reflectwalk v1.0.0 // indirect

github.com/mitchellh/copystructure v1.0.0 h1:Laisrj+bAB6b/yJwB5Bt3ITZhGJdqmxquMKeZ+mmkFQ=
github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw=
github.com/mitchellh/reflectwalk v1.0.0 h1:9D+8oIskB4VJBN5SFlmc27fSlIBZaov1Wpk/IfikLNY=
github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=

package main

import (
	"fmt"
	"reflect"

	"github.com/mitchellh/copystructure"
)

// CustomData represents a data structure with custom copy handling.
type CustomData struct {
	Value string
	Tag   string
}

func main() {
	// Register custom copier in global copystructure.Copiers
	copystructure.Copiers[reflect.TypeOf(CustomData{})] = func(v interface{}) (interface{}, error) {
		orig := v.(CustomData)
		return CustomData{
			Value: orig.Value,
			Tag:   "cloned",
		}, nil
	}

	orig := CustomData{Value: "sample-payload", Tag: "initial"}
	cloned, err := copystructure.Copy(orig)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Original: %+v\n", orig)
	fmt.Printf("Cloned:   %+v\n", cloned)
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/mitchellh/copystructure.Copiers in pkg:golang/github.com/mitchellh/copystructure@v1.0.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/mitchellh/copystructure@v1.0.0"
  ],
  "symbols": [
    "github.com/mitchellh/copystructure.Copiers"
  ]
}

package main

import (
	"errors"
	"fmt"
	"os"
	"reflect"
	"time"

	"github.com/mitchellh/copystructure"
)

type Payload struct {
	Text string
}

type Container struct {
	Item    Payload
	Items   []Payload
	ItemMap map[string]Payload
}

type FailingStruct struct {
	ID int
}

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

func runContract() error {
	// Assertion 1: copystructure.Copiers contains predefined type copiers including time.Time
	if _, ok := copystructure.Copiers[reflect.TypeOf(time.Time{})]; !ok {
		return errors.New("Assertion 1 failed: expected time.Time in copystructure.Copiers")
	}

	// Assertion 2: copystructure.Copiers map registers custom CopierFunc for struct types to override standard deep copy
	var payloadCopierCalls int
	copystructure.Copiers[reflect.TypeOf(Payload{})] = func(v interface{}) (interface{}, error) {
		payloadCopierCalls++
		p, ok := v.(Payload)
		if !ok {
			return nil, errors.New("expected Payload type")
		}
		return Payload{Text: p.Text + "-custom"}, nil
	}

	p := Payload{Text: "base"}
	copiedAny, err := copystructure.Copy(p)
	if err != nil {
		return fmt.Errorf("Assertion 2 failed: copystructure.Copy error: %w", err)
	}
	copiedPayload, ok := copiedAny.(Payload)
	if !ok {
		return fmt.Errorf("Assertion 2 failed: expected Payload, got %T", copiedAny)
	}
	if payloadCopierCalls != 1 {
		return fmt.Errorf("Assertion 2 failed: expected 1 copier call, got %d", payloadCopierCalls)
	}
	if copiedPayload.Text != "base-custom" {
		return fmt.Errorf("Assertion 2 failed: expected text 'base-custom', got %q", copiedPayload.Text)
	}

	// Assertion 3: copystructure.Copy executes custom CopierFunc registered in copystructure.Copiers for nested structs
	payloadCopierCalls = 0
	container := Container{
		Item: Payload{Text: "single"},
		Items: []Payload{
			{Text: "slice-1"},
			{Text: "slice-2"},
		},
		ItemMap: map[string]Payload{
			"key1": {Text: "map-1"},
		},
	}

	copiedContainerAny, err := copystructure.Copy(container)
	if err != nil {
		return fmt.Errorf("Assertion 3 failed: copystructure.Copy error: %w", err)
	}
	copiedContainer, ok := copiedContainerAny.(Container)
	if !ok {
		return fmt.Errorf("Assertion 3 failed: expected Container, got %T", copiedContainerAny)
	}
	// Expected calls: 1 (field) + 2 (slice) + 1 (map) = 4
	if payloadCopierCalls != 4 {
		return fmt.Errorf("Assertion 3 failed: expected 4 copier calls, got %d", payloadCopierCalls)
	}
	if copiedContainer.Item.Text != "single-custom" {
		return fmt.Errorf("Assertion 3 failed: expected 'single-custom', got %q", copiedContainer.Item.Text)
	}
	if copiedContainer.Items[0].Text != "slice-1-custom" || copiedContainer.Items[1].Text != "slice-2-custom" {
		return fmt.Errorf("Assertion 3 failed: slice elements not transformed")
	}
	if copiedContainer.ItemMap["key1"].Text != "map-1-custom" {
		return fmt.Errorf("Assertion 3 failed: map element not transformed")
	}

	// Assertion 4: copystructure.Copiers function returning an error propagates that error out of copystructure.Copy
	expectedErr := errors.New("deliberate copy failure")
	copystructure.Copiers[reflect.TypeOf(FailingStruct{})] = func(v interface{}) (interface{}, error) {
		return nil, expectedErr
	}

	_, err = copystructure.Copy(FailingStruct{ID: 1})
	if err == nil {
		return errors.New("Assertion 4 failed: expected error from copystructure.Copy, got nil")
	}
	if !errors.Is(err, expectedErr) {
		return fmt.Errorf("Assertion 4 failed: expected %v, got %v", expectedErr, err)
	}

	return nil
}