Forklift buildx provider

provider/internal/preview.go

@@ -0,0 +1,117 @@
+// Copyright 2024, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package internal
+
+import (
+	"fmt"
+)
+
+// keeper decides whether an element should be included for a preview
+// operation, optionally returning a mutated copy of that element.
+type keeper[T any] interface {
+	keep(T) bool
+}
+
+// filter applies a keeper to each element, returning a new slice.
+func filter[T any](k keeper[T], elems ...T) []T {
+	if elems == nil {
+		return nil
+	}
+	result := make([]T, 0, len(elems))
+	for _, e := range elems {
+		if !k.keep(e) {
+			continue
+		}
+		result = append(result, e)
+	}
+	return result
+}
+
+// stringKeeper preserves any non-empty string values for preview.
+type stringKeeper struct{ preview bool }
+
+func (k stringKeeper) keep(s string) bool {
+	if !k.preview {
+		return true
+	}
+	return s != ""
+}
+
+//nolint:structcheck // False positive due to generics.
+type stringerKeeper[T fmt.Stringer] struct{ preview bool }
+
+//nolint:unused // False positive due to generics.
+func (k stringerKeeper[T]) keep(t T) bool {
+	if !k.preview {
+		return true
+	}
+	return stringKeeper(k).keep(t.String())
+}
+
+// registryKeeper preserves any registries with known values for address and
+// password. This is imprecise and doesn't permit alternative auth strategies
+// like registry tokens, email, etc.
+type registryKeeper struct{ preview bool }
+
+//nolint:unused // False positive due to generics.
+func (k registryKeeper) keep(r Registry) bool {
+	if !k.preview {
+		return true
+	}
+	return r.Password != "" && r.Address != ""
+}
+
+// mapKeeper preserves map elements with known keys and values.
+type mapKeeper struct{ preview bool }
+
+func (k mapKeeper) keep(m map[string]string) map[string]string {
+	if !k.preview || len(m) == 0 {
+		return m
+	}
+	kk := stringKeeper(k)
+	filtered := make(map[string]string)
+	for key, val := range m {
+		if !kk.keep(key) {
+			continue
+		}
+		if !kk.keep(val) {
+			continue
+		}
+		filtered[key] = val
+	}
+	return filtered
+}
+
+type contextKeeper struct{ preview bool }
+
+func (k contextKeeper) keep(bc BuildContext) BuildContext {
+	if !k.preview || len(bc.Named) == 0 {
+		return bc
+	}
+
+	named := NamedContexts{}
+	sk := stringKeeper(k)
+	for k, v := range bc.Named {
+		if !sk.keep(k) || !sk.keep(v.Location) {
+			continue
+		}
+		named[k] = v
+	}
+
+	return BuildContext{
+		Context: Context{bc.Location},
+		Named:   named,
+	}
+}