Skip to content

Commit

Permalink
Remove repetitive "loc" in names
Browse files Browse the repository at this point in the history
  • Loading branch information
@annasong20
annasong20 committed Nov 9, 2022
1 parent ea59bd7 commit 4b33348
Show file tree
Hide file tree
Showing 2 changed files with 38 additions and 39 deletions.
41 changes: 20 additions & 21 deletions api/internal/localizer/locloader.go
View file
Expand Up @@ -16,8 +16,8 @@ import (

const dstPrefix = "localized"

// LocArgs holds localize arguments
type LocArgs struct {
// Args holds localize arguments
type Args struct {
// target; local copy if remote
Target filesys.ConfirmedDir

Expand All @@ -28,55 +28,54 @@ type LocArgs struct {
NewDir filesys.ConfirmedDir
}

// locLoader is the Loader for kustomize localize. It is an ifc.Loader that enforces localize constraints.
type locLoader struct {
// Loader is an ifc.Loader that enforces additional constraints specific to kustomize localize.
type Loader struct {
fSys filesys.FileSystem

args *LocArgs
args *Args

// loader at locLoader's current directory
// loader at Loader's current directory
ifc.Loader

// whether locLoader and all its ancestors are the result of local references
// whether Loader and all its ancestors are the result of local references
local bool
}

var _ ifc.Loader = &locLoader{}
var _ ifc.Loader = &Loader{}

// NewLocLoader is the factory method for Loader, under localize constraints, at rawTarget. For invalid localize arguments,
// NewLocLoader returns an error.
func NewLocLoader(rawTarget string, rawScope string, rawNewDir string, fSys filesys.FileSystem) (ifc.Loader, LocArgs, error) {
// NewLoader is the factory method for Loader, under localize constraints, at rawTarget. For invalid localize arguments,
// NewLoader returns an error.
func NewLoader(rawTarget string, rawScope string, rawNewDir string, fSys filesys.FileSystem) (*Loader, Args, error) {
// check earlier to avoid cleanup
repoSpec, err := git.NewRepoSpecFromURL(rawTarget)
if err == nil && repoSpec.Ref == "" {
return nil, LocArgs{},
errors.Errorf("localize remote root %q missing ref query string parameter", rawTarget)
return nil, Args{}, errors.Errorf("localize remote root %q missing ref query string parameter", rawTarget)
}

// for security, should enforce load restrictions
ldr, err := loader.NewLoader(loader.RestrictionRootOnly, rawTarget, fSys)
if err != nil {
return nil, LocArgs{}, errors.WrapPrefixf(err, "unable to establish localize target %q", rawTarget)
return nil, Args{}, errors.WrapPrefixf(err, "unable to establish localize target %q", rawTarget)
}

scope, err := establishScope(rawScope, rawTarget, ldr, fSys)
if err != nil {
_ = ldr.Cleanup()
return nil, LocArgs{}, errors.WrapPrefixf(err, "invalid localize scope %q", rawScope)
return nil, Args{}, errors.WrapPrefixf(err, "invalid localize scope %q", rawScope)
}

newDir, err := createNewDir(rawNewDir, ldr, repoSpec, fSys)
if err != nil {
_ = ldr.Cleanup()
return nil, LocArgs{}, errors.WrapPrefixf(err, "invalid localize destination %q", rawNewDir)
return nil, Args{}, errors.WrapPrefixf(err, "invalid localize destination %q", rawNewDir)
}

args := LocArgs{
args := Args{
Target: filesys.ConfirmedDir(ldr.Root()),
Scope: scope,
NewDir: newDir,
}
return &locLoader{
return &Loader{
fSys: fSys,
args: &args,
Loader: ldr,
Expand All @@ -86,7 +85,7 @@ func NewLocLoader(rawTarget string, rawScope string, rawNewDir string, fSys file

// Load returns the contents of path if path is a valid localize file.
// Otherwise, Load returns an error.
func (ll *locLoader) Load(path string) ([]byte, error) {
func (ll *Loader) Load(path string) ([]byte, error) {
// checks in root, and thus in scope
content, err := ll.Loader.Load(path)
if err != nil {
Expand Down Expand Up @@ -115,7 +114,7 @@ func (ll *locLoader) Load(path string) ([]byte, error) {

// New returns a Loader at path if path is a valid localize root.
// Otherwise, New returns an error.
func (ll *locLoader) New(path string) (ifc.Loader, error) {
func (ll *Loader) New(path string) (ifc.Loader, error) {
ldr, err := ll.Loader.New(path)
if err != nil {
return nil, errors.WrapPrefixf(err, "invalid root reference")
Expand All @@ -133,7 +132,7 @@ func (ll *locLoader) New(path string) (ifc.Loader, error) {
return nil, errors.Errorf("localize remote root %q missing ref query string parameter", path)
}

return &locLoader{
return &Loader{
fSys: ll.fSys,
args: ll.args,
Loader: ldr,
Expand Down
36 changes: 18 additions & 18 deletions api/internal/localizer/locloader_test.go
View file
Expand Up @@ -10,7 +10,7 @@ import (

"github.com/stretchr/testify/require"
"sigs.k8s.io/kustomize/api/ifc"
lclzr "sigs.k8s.io/kustomize/api/internal/localizer"
. "sigs.k8s.io/kustomize/api/internal/localizer"
"sigs.k8s.io/kustomize/kyaml/filesys"
)

Expand All @@ -31,17 +31,17 @@ func makeMemoryFs(t *testing.T) filesys.FileSystem {
return fSys
}

func checkNewLocLoader(req *require.Assertions, ldr ifc.Loader, args *lclzr.LocArgs, target string, scope string, newDir string, fSys filesys.FileSystem) {
func checkNewLoader(req *require.Assertions, ldr *Loader, args *Args, target string, scope string, newDir string, fSys filesys.FileSystem) {
checkLoader(req, ldr, target)
checkLocArgs(req, args, target, scope, newDir, fSys)
checkArgs(req, args, target, scope, newDir, fSys)
}

func checkLoader(req *require.Assertions, ldr ifc.Loader, root string) {
req.Equal(root, ldr.Root())
req.Empty(ldr.Repo())
}

func checkLocArgs(req *require.Assertions, args *lclzr.LocArgs, target string, scope string, newDir string, fSys filesys.FileSystem) {
func checkArgs(req *require.Assertions, args *Args, target string, scope string, newDir string, fSys filesys.FileSystem) {
req.Equal(target, args.Target.String())
req.Equal(scope, args.Scope.String())
req.Equal(newDir, args.NewDir.String())
Expand All @@ -55,9 +55,9 @@ func TestLocalLoadNewAndCleanup(t *testing.T) {
var buf bytes.Buffer
log.SetOutput(&buf)
// typical setup
ldr, args, err := lclzr.NewLocLoader("a", "/", "/newDir", fSys)
ldr, args, err := NewLoader("a", "/", "/newDir", fSys)
req.NoError(err)
checkNewLocLoader(req, ldr, &args, "/a", "/", "/newDir", fSys)
checkNewLoader(req, ldr, &args, "/a", "/", "/newDir", fSys)

fSysCopy := makeMemoryFs(t)
req.NoError(fSysCopy.Mkdir("/newDir"))
Expand Down Expand Up @@ -102,9 +102,9 @@ func TestNewLocLoaderDefaultForRootTarget(t *testing.T) {
req := require.New(t)
fSys := makeMemoryFs(t)

ldr, args, err := lclzr.NewLocLoader(params.target, params.scope, "", fSys)
ldr, args, err := NewLoader(params.target, params.scope, "", fSys)
req.NoError(err)
checkNewLocLoader(req, ldr, &args, "/", "/", "/"+dstPrefix, fSys)
checkNewLoader(req, ldr, &args, "/", "/", "/"+dstPrefix, fSys)

// file in root, but nested
content, err := ldr.Load("a/kustomization.yaml")
Expand All @@ -129,9 +129,9 @@ func TestNewMultiple(t *testing.T) {

// default destination for non-file system root target
// destination outside of scope
ldr, args, err := lclzr.NewLocLoader("/alpha/beta", "/alpha", "", fSys)
ldr, args, err := NewLoader("/alpha/beta", "/alpha", "", fSys)
req.NoError(err)
checkNewLocLoader(req, ldr, &args, "/alpha/beta", "/alpha", "/"+dstPrefix+"-beta", fSys)
checkNewLoader(req, ldr, &args, "/alpha/beta", "/alpha", "/"+dstPrefix+"-beta", fSys)

// nested child root that isn't cleaned
descLdr, err := ldr.New("../beta/gamma/delta")
Expand Down Expand Up @@ -190,7 +190,7 @@ func TestNewLocLoaderCwdNotRoot(t *testing.T) {
req := require.New(t)
fSys := makeWdFs(t)[test.wd]

ldr, args, err := lclzr.NewLocLoader(test.target, test.scope, test.newDir, fSys)
ldr, args, err := NewLoader(test.target, test.scope, test.newDir, fSys)
req.NoError(err)
checkLoader(req, ldr, "a/b/c/d/e")

Expand Down Expand Up @@ -240,7 +240,7 @@ func TestNewLocLoaderFails(t *testing.T) {
t.Run(name, func(t *testing.T) {
var buf bytes.Buffer
log.SetOutput(&buf)
_, _, err := lclzr.NewLocLoader(params.target, params.scope, params.dest, makeMemoryFs(t))
_, _, err := NewLoader(params.target, params.scope, params.dest, makeMemoryFs(t))
require.Error(t, err)
require.Empty(t, buf.String())
})
Expand All @@ -251,9 +251,9 @@ func TestNewFails(t *testing.T) {
req := require.New(t)
fSys := makeMemoryFs(t)

ldr, args, err := lclzr.NewLocLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
ldr, args, err := NewLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
req.NoError(err)
checkNewLocLoader(req, ldr, &args, "/alpha/beta/gamma", "/alpha", "/alpha/beta/gamma/newDir", fSys)
checkNewLoader(req, ldr, &args, "/alpha/beta/gamma", "/alpha", "/alpha/beta/gamma/newDir", fSys)

cases := map[string]string{
"outside scope": "../../../a",
Expand All @@ -267,7 +267,7 @@ func TestNewFails(t *testing.T) {
t.Run(name, func(t *testing.T) {
fSys := makeMemoryFs(t)

ldr, _, err := lclzr.NewLocLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
ldr, _, err := NewLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
require.NoError(t, err)

_, err = ldr.New(root)
Expand All @@ -280,9 +280,9 @@ func TestLoadFails(t *testing.T) {
req := require.New(t)
fSys := makeMemoryFs(t)

ldr, args, err := lclzr.NewLocLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
ldr, args, err := NewLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
req.NoError(err)
checkNewLocLoader(req, ldr, &args, "/a", "/a", "/a/newDir", fSys)
checkNewLoader(req, ldr, &args, "/a", "/a", "/a/newDir", fSys)

cases := map[string]string{
"absolute path": "/a/kustomization.yaml",
Expand All @@ -297,7 +297,7 @@ func TestLoadFails(t *testing.T) {
req := require.New(t)
fSys := makeMemoryFs(t)

ldr, _, err := lclzr.NewLocLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
ldr, _, err := NewLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
req.NoError(err)

req.NoError(fSys.WriteFile("/a/newDir/kustomization.yaml", []byte("/a/newDir")))
Expand Down

0 comments on commit 4b33348

Please sign in to comment.