Move optional and pointer to opensource, update lint rules (#480)

## Summary
This PR does two simple changes:
- It makes our linting rules very close to the ones in Axiom
- It moves the code for the optional on-pointer packages from Axiom to
open source. This is a straight copy of the code, with no functionality
or logic changes

## How was it tested?
Ran unit tests

## Community Contribution License

All community contributions in this pull request are licensed to the
project maintainers under the terms of the [Apache 2
License](https://www.apache.org/licenses/LICENSE-2.0).

By creating this pull request I represent that I have the right to
license the contributions to the project maintainers under the Apache 2
License as stated in the [Community Contribution
License](https://github.com/jetify-com/opensource/blob/main/CONTRIBUTING.md#community-contribution-license).

---------

Signed-off-by: Daniel Loreto <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: loreto

.golangci.yml

@@ -1,13 +1,11 @@
-# TODO(Landau): Turn on all linters
-# TODO(Landau): move this to top level of opensource?
 run:
   go: "1.23"
 linters:
   disable-all: true
   enable:
     - dupl
-    - errorlint
     - errcheck
+    - errorlint
     - gofmt
     - goimports
     - gosimple
@@ -27,14 +25,34 @@ linters:
     - usestdlibvars
     - usetesting
     - varnamelen
-    # If we're going to use github.com/pkg/errors we should probably turn this on?
-    # Let's adopt new stackerr lib and we can turn this on.
     # - wrapcheck
-    - unused
+issues:
+  exclude-files:
+    - ".*\\.connect\\.go$"
+    - ".*\\.pb\\.go$"
+  exclude:
+    # It's usually better to start off _not_ wrapping an error unless it
+    # should be part of your API. Errors should be wrapped only when it's
+    # useful.
+    #
+    # See https://go.dev/blog/go1.13-errors
+    - "non-wrapping format verb for fmt.Errorf"
+  exclude-rules:
+    - path: _test\.go
+      linters:
+        - dupl
 
+    # TODO(gcurtis): temporary until this file is used.
+    - path: terminal.*\.go
+      linters:
+        - unused
 linters-settings:
-  errorlint:
-    errorf: false
+  errcheck:
+    exclude-functions:
+      # Dropped/canceled/timed out connections or bad clients make checking this
+      # error pointless 99% of the time.
+      - (net/http.ResponseWriter).Write
+      - (flag/*FlagSet).Parse
   revive:
     rules: # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md
       - name: atomic
@@ -56,15 +74,38 @@ linters-settings:
       - name: var-naming
       - name: unreachable-code
   varnamelen:
-    max-distance: 10
+    max-distance: 40
     ignore-decls:
-      - id []byte
+      - c echo.Context
+      - const C
+      - db database.Db
+      - db db
+      - e error
+      - e watch.Event
+      - f *foo.Bar
+      - i int
+      - id string
+      - id any
+      - m map[string]any
+      - m map[string]int
+      - mc api.CliServiceClient
+      - ns *komponents.Namespace
+      - ns komponents.Namespace
+      - ns string
       - r *http.Request
-      - r io.Reader
+      - T any
       - t testing.T
-      - v any
+      - vc *viewer.MockViewer
+      - vc Context
+      - vc viewer
+      - vc viewer.CommonContext
+      - vc viewer.Context
       - w http.ResponseWriter
       - w io.Writer
-  # TODO: enable this
-  # unparam:
-  #   check-exported: true
+  unconvert:
+    fast-math: true
+  wrapcheck:
+    ignoreSigRegexps:
+      - ".*confkit.*Validate.*"
+    ignorePackageGlobs:
+      - "go.jetify.com/axiom/api/*"

pkg/optional/doc.go

@@ -0,0 +1,56 @@
+// Package optional provides a generic Option[T] type and helpers for representing
+// values that may or may not be present.
+//
+// The Option[T] type is a lightweight, allocation-free abstraction similar to the
+// "Maybe" or "Optional" types found in other languages.  It is useful for
+// expressing that a value might be absent without resorting to pointers or
+// sentinel values.
+//
+// # Basic construction
+//
+// There are two canonical constructors:
+//
+//	opt := optional.Some(42) // value is set
+//	opt := optional.None[int]() // value is not set
+//
+// Accessing values
+//
+//	v, ok := opt.Get()         // returns value and whether it is set
+//	v := opt.GetOrElse(0)      // returns value or a default
+//	v := opt.MustGet()         // panics if value is not set
+//	if opt.IsNone() { ... }    // tests for absence
+//
+// Pointers
+//
+//	opt := optional.Ptr(ptr)   // wraps a *T, set to the value of ptr when ptr != nil
+//
+// # Primitive helpers
+//
+// For convenience the package exposes helper constructors for primitive types:
+//
+//	optional.Int(1)        // Option[int]
+//	optional.Float64(3.14) // Option[float64]
+//	optional.String("hi") // Option[string]
+//
+// These are entirely equivalent to calling Some(value) but sometimes improve
+// readability.
+//
+// # JSON integration
+//
+// Option implements json.Marshaler and json.Unmarshaler.  A None value
+// marshals to JSON null, while Some(value) marshals to the JSON representation
+// of the contained value.
+//
+// When Option fields are used inside structs the 'omitzero' tag can be used to
+// omit None() values entirely:
+//
+//	type Person struct {
+//	    Name string          `json:"name"`
+//	    Age  optional.Option[int] `json:"age,omitzero"` // omitted when None
+//	}
+//
+// # Zero value behavior
+//
+// The zero value of Option[T] is considered "not set" (None).  As a result an
+// Option field in a struct that is left uninitialized will behave as None().
+package optional

pkg/optional/optional.go

@@ -0,0 +1,125 @@
+package optional
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// Option represents an optional value of type T
+type Option[T any] struct {
+	value T
+	set   bool
+}
+
+// Some creates a value that is set
+func Some[T any](value T) Option[T] {
+	return Option[T]{
+		value: value,
+		set:   true,
+	}
+}
+
+// None creates an empty value that is not set
+func None[T any]() Option[T] {
+	return Option[T]{
+		set: false,
+	}
+}
+
+// Ptr creates an Option value from a pointer.
+// The value is set if the pointer is not nil, and not set if the pointer is nil.
+//
+// T should not be a pointer type.
+func Ptr[T any](ptr *T) Option[T] {
+	if ptr == nil {
+		return None[T]()
+	}
+	return Some(*ptr)
+}
+
+// Get returns the underlying value and whether it's set
+func (o Option[T]) Get() (T, bool) {
+	return o.value, o.set
+}
+
+// MustGet returns the value or panics if not set
+func (o Option[T]) MustGet() T {
+	if !o.set {
+		panic("option value not set")
+	}
+	return o.value
+}
+
+// GetOrElse returns the contained value or a default if it is not set
+func (o Option[T]) GetOrElse(defaultValue T) T {
+	if !o.set {
+		return defaultValue
+	}
+	return o.value
+}
+
+// IsNone returns true if there is no set value
+func (o Option[T]) IsNone() bool {
+	return !o.set
+}
+
+// String returns a textual representation for debugging/logging
+func (o Option[T]) String() string {
+	if !o.set {
+		return "None"
+	}
+	return fmt.Sprintf("Some(%v)", o.value)
+}
+
+// GoString returns a Go-syntax representation
+func (o Option[T]) GoString() string {
+	if !o.set {
+		return fmt.Sprintf("None[%T]()", o.value)
+	}
+	return fmt.Sprintf("Some[%T](%#v)", o.value, o.value)
+}
+
+// MarshalJSON implements json.Marshaler interface.
+// Some(value) marshals to the value's JSON representation
+// None() marshals to JSON null
+//
+// When used with struct fields:
+//
+//   - None() appears as null by default
+//
+//   - With 'omitzero' tag: None() values are omitted from JSON
+//
+//     type Person struct {
+//     Name    string       `json:"name"`
+//     Age     Option[int]  `json:"age,omitzero"`   // Omitted when None
+//     Address Option[string] `json:"address"`      // Appears as null when None
+//     }
+func (o Option[T]) MarshalJSON() ([]byte, error) {
+	if !o.set {
+		return []byte("null"), nil
+	}
+	return json.Marshal(o.value)
+}
+
+// UnmarshalJSON implements json.Unmarshaler interface.
+// JSON null becomes None(), other values become Some(value)
+func (o *Option[T]) UnmarshalJSON(data []byte) error {
+	if string(data) == "null" {
+		*o = None[T]()
+		return nil
+	}
+
+	var value T
+	if err := json.Unmarshal(data, &value); err != nil {
+		return err
+	}
+
+	*o = Some(value)
+	return nil
+}
+
+// IsZero returns 'false' if the value is set, and 'true' if it is not set.
+// It makes Option compatible with the 'omitzero' JSON tag.
+func (o Option[T]) IsZero() bool {
+	return !o.set
+}