github.com/spf13/pflag v1.0.10: FlagSet

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/spf13/pflag.FlagSet in pkg:golang/github.com/spf13/pflag@v1.0.10
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/spf13/pflag@v1.0.10
Demonstrate these symbols/APIs:
  - github.com/spf13/pflag.FlagSet
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.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:cf29bf7b9e5ad42b575c05a8f63a30e85b02e7df9bdb4574c96247421fc1adde","contract":["pflag.FlagSet defines and parses typed flags with default values and shorthands","pflag.FlagSet tracks changed flags, positional arguments, and reports errors for unknown flags"],"goal":"verify github.com/spf13/pflag.FlagSet in pkg:golang/github.com/spf13/pflag@v1.0.10","kind":"HOW","packages":["pkg:golang/github.com/spf13/pflag@v1.0.10"],"schemaVersion":1,"symbols":["github.com/spf13/pflag.FlagSet"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/spf13/pflag@v1.0.10"],"schemaVersion":1,"subject":"pkg:golang/github.com/spf13/pflag@v1.0.10","symbols":["github.com/spf13/pflag.FlagSet"],"verifierAdapter":"golang@1"}

module example.com/pflag-sample

go 1.26.6

require github.com/spf13/pflag v1.0.10

github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=

package pflagcli

import (
	"time"

	"github.com/spf13/pflag"
)

// Options holds CLI configuration values bound to flags.
type Options struct {
	Host    string
	Port    int
	Verbose bool
	Tags    []string
	Timeout time.Duration
}

// BuildFlagSet creates a new FlagSet with typed options.
func BuildFlagSet(name string, opts *Options) *pflag.FlagSet {
	fs := pflag.NewFlagSet(name, pflag.ContinueOnError)
	fs.StringVarP(&opts.Host, "host", "H", "127.0.0.1", "Target host address")
	fs.IntVarP(&opts.Port, "port", "p", 8080, "Target port number")
	fs.BoolVarP(&opts.Verbose, "verbose", "v", false, "Enable verbose logging")
	fs.StringSliceVarP(&opts.Tags, "tags", "t", []string{}, "Comma-separated tag list")
	fs.DurationVarP(&opts.Timeout, "timeout", "T", 10*time.Second, "Operation timeout")
	return fs
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/spf13/pflag.FlagSet in pkg:golang/github.com/spf13/pflag@v1.0.10",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/spf13/pflag@v1.0.10"
  ],
  "symbols": [
    "github.com/spf13/pflag.FlagSet"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

package main

import (
	"fmt"
	"os"
	"time"

	pflagcli "example.com/pflag-sample"
	"github.com/spf13/pflag"
)

func main() {
	// Assertion 1: Verify default flag values without arguments
	var defaultOpts pflagcli.Options
	fs1 := pflagcli.BuildFlagSet("defaults-test", &defaultOpts)
	if err := fs1.Parse([]string{}); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: parsing empty args failed: %v\n", err)
		os.Exit(1)
	}
	if defaultOpts.Host != "127.0.0.1" || defaultOpts.Port != 8080 || defaultOpts.Verbose != false || len(defaultOpts.Tags) != 0 || defaultOpts.Timeout != 10*time.Second {
		fmt.Fprintf(os.Stderr, "FAIL: default flag values mismatch: %+v\n", defaultOpts)
		os.Exit(1)
	}
	if fs1.Changed("host") || fs1.Changed("port") || fs1.Changed("verbose") || fs1.Changed("tags") || fs1.Changed("timeout") {
		fmt.Fprintf(os.Stderr, "FAIL: Changed() reported true for unsupplied flags\n")
		os.Exit(1)
	}

	// Assertion 2: Parse short flags, long flags, type conversions, and positional arguments
	var parsedOpts pflagcli.Options
	fs2 := pflagcli.BuildFlagSet("parse-test", &parsedOpts)
	args := []string{
		"-H", "example.com",
		"-p", "9090",
		"-v",
		"--tags", "web,api,v1",
		"--timeout", "30s",
		"extra-arg-1",
		"extra-arg-2",
	}
	if err := fs2.Parse(args); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: parsing args failed: %v\n", err)
		os.Exit(1)
	}
	if parsedOpts.Host != "example.com" || parsedOpts.Port != 9090 || parsedOpts.Verbose != true || len(parsedOpts.Tags) != 3 || parsedOpts.Timeout != 30*time.Second {
		fmt.Fprintf(os.Stderr, "FAIL: parsed flag values mismatch: %+v\n", parsedOpts)
		os.Exit(1)
	}
	if parsedOpts.Tags[0] != "web" || parsedOpts.Tags[1] != "api" || parsedOpts.Tags[2] != "v1" {
		fmt.Fprintf(os.Stderr, "FAIL: slice tags mismatch: %v\n", parsedOpts.Tags)
		os.Exit(1)
	}
	if !fs2.Changed("host") || !fs2.Changed("port") || !fs2.Changed("verbose") || !fs2.Changed("tags") || !fs2.Changed("timeout") {
		fmt.Fprintf(os.Stderr, "FAIL: Changed() reported false for supplied flags\n")
		os.Exit(1)
	}
	if fs2.NArg() != 2 || fs2.Args()[0] != "extra-arg-1" || fs2.Args()[1] != "extra-arg-2" {
		fmt.Fprintf(os.Stderr, "FAIL: positional args mismatch: %v\n", fs2.Args())
		os.Exit(1)
	}

	// Assertion 3: FlagSet getters, lookup, and dynamic modification
	directFS := pflag.NewFlagSet("lookup-test", pflag.ContinueOnError)
	directFS.IntP("retries", "r", 3, "retry count")
	directFS.String("endpoint", "/status", "endpoint path")

	if err := directFS.Parse([]string{"-r", "5", "--endpoint=/health"}); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: direct flag parse failed: %v\n", err)
		os.Exit(1)
	}
	retries, err := directFS.GetInt("retries")
	if err != nil || retries != 5 {
		fmt.Fprintf(os.Stderr, "FAIL: GetInt failed: %v, val: %d\n", err, retries)
		os.Exit(1)
	}
	endpoint, err := directFS.GetString("endpoint")
	if err != nil || endpoint != "/health" {
		fmt.Fprintf(os.Stderr, "FAIL: GetString failed: %v, val: %s\n", err, endpoint)
		os.Exit(1)
	}
	flagObj := directFS.Lookup("retries")
	if flagObj == nil || flagObj.Shorthand != "r" || flagObj.Value.String() != "5" {
		fmt.Fprintf(os.Stderr, "FAIL: Lookup failed or flag object mismatch: %+v\n", flagObj)
		os.Exit(1)
	}

	// Assertion 4: Error handling on unknown flag with ContinueOnError
	errFS := pflag.NewFlagSet("error-test", pflag.ContinueOnError)
	errFS.String("mode", "prod", "mode setting")
	if err := errFS.Parse([]string{"--nonexistent-flag"}); err == nil {
		fmt.Fprintf(os.Stderr, "FAIL: expected error on unknown flag, got nil\n")
		os.Exit(1)
	}

	fmt.Println("PASS: pflag.FlagSet contract assertions verified")
}