diff --git a/changes/20240902105601.bugfix b/changes/20240902105601.bugfix new file mode 100644 index 0000000000..9478ea5b08 --- /dev/null +++ b/changes/20240902105601.bugfix @@ -0,0 +1 @@ +:bug: `[filesystem]` Made LsRecursive global and changed some function names to avoid confusion \ No newline at end of file diff --git a/utils/filesystem/files.go b/utils/filesystem/files.go index 6405e3b4bb..d8a1b743d1 100644 --- a/utils/filesystem/files.go +++ b/utils/filesystem/files.go @@ -1128,15 +1128,25 @@ func (fs *VFS) LsWithExclusionPatterns(dir string, exclusionPatterns ...string) return } +// LsRecursive lists all files recursively, including subdirectories +func LsRecursive(ctx context.Context, dir string, includeDirectories bool) (files []string, err error) { + return GetGlobalFileSystem().LsRecursive(ctx, dir, includeDirectories) +} + +// LsRecursiveWithExclusionPatterns lists all files and directory (equivalent to ls) but exclude the ones matching the exclusion patterns. +func LsRecursiveWithExclusionPatterns(ctx context.Context, dir string, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) { + return GetGlobalFileSystem().LsRecursiveWithExclusionPatterns(ctx, dir, includeDirectories, exclusionPatterns...) +} + func (fs *VFS) LsRecursive(ctx context.Context, dir string, includeDirectories bool) (files []string, err error) { - return fs.LsRecursiveWithExtensionPatternsAndLimits(ctx, dir, NoLimits(), includeDirectories) + return fs.LsRecursiveWithExclusionPatternsAndLimits(ctx, dir, NoLimits(), includeDirectories) } -func (fs *VFS) LsRecursiveWithExtensionPatterns(ctx context.Context, dir string, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) { - return fs.LsRecursiveWithExtensionPatternsAndLimits(ctx, dir, NoLimits(), includeDirectories, exclusionPatterns...) +func (fs *VFS) LsRecursiveWithExclusionPatterns(ctx context.Context, dir string, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) { + return fs.LsRecursiveWithExclusionPatternsAndLimits(ctx, dir, NoLimits(), includeDirectories, exclusionPatterns...) } -func (fs *VFS) LsRecursiveWithExtensionPatternsAndLimits(ctx context.Context, dir string, limits ILimits, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) { +func (fs *VFS) LsRecursiveWithExclusionPatternsAndLimits(ctx context.Context, dir string, limits ILimits, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) { err = parallelisation.DetermineContextError(ctx) if err != nil { return diff --git a/utils/filesystem/files_test.go b/utils/filesystem/files_test.go index 479deb2862..86947528b9 100644 --- a/utils/filesystem/files_test.go +++ b/utils/filesystem/files_test.go @@ -2108,7 +2108,7 @@ func TestLsRecursive(t *testing.T) { } } -func TestLsRecursiveWithExtensionPatterns(t *testing.T) { +func TestLsRecursiveWithExclusionPatterns(t *testing.T) { for _, fsType := range FileSystemTypes { t.Run("Test LsRecursiveWithExtensionPatterns includes directories with exclusion patterns", func(t *testing.T) { fs := NewFs(fsType) @@ -2122,7 +2122,7 @@ func TestLsRecursiveWithExtensionPatterns(t *testing.T) { globToRegex("*.jar"), } - result, err := fs.LsRecursiveWithExtensionPatterns(context.Background(), rootDir, true, exclusionPatterns...) + result, err := fs.LsRecursiveWithExclusionPatterns(context.Background(), rootDir, true, exclusionPatterns...) require.NoError(t, err) expectedFiles := []string{ filepath.Join(rootDir, "dir2", "dir3", "dir4", "test1.txt"), @@ -2151,7 +2151,7 @@ func TestLsRecursiveWithExtensionPatterns(t *testing.T) { globToRegex("*.jar"), } - result, err := fs.LsRecursiveWithExtensionPatterns(context.Background(), rootDir, false, exclusionPatterns...) + result, err := fs.LsRecursiveWithExclusionPatterns(context.Background(), rootDir, false, exclusionPatterns...) require.NoError(t, err) expectedFiles := []string{ filepath.Join(rootDir, "dir2", "dir3", "dir4", "test1.txt"), @@ -2172,7 +2172,7 @@ func TestLsRecursiveWithExtensionPatterns(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) cancel() - result, err := fs.LsRecursiveWithExtensionPatterns(ctx, rootDir, true) + result, err := fs.LsRecursiveWithExclusionPatterns(ctx, rootDir, true) errortest.AssertError(t, err, commonerrors.ErrCancelled, commonerrors.ErrTimeout) assert.Empty(t, result, "Expected no results when context is canceled") }) @@ -2182,14 +2182,14 @@ func TestLsRecursiveWithExtensionPatterns(t *testing.T) { nonExistentDir := filepath.Join(t.TempDir(), "non_existent_dir") - result, err := fs.LsRecursiveWithExtensionPatterns(context.Background(), nonExistentDir, true) + result, err := fs.LsRecursiveWithExclusionPatterns(context.Background(), nonExistentDir, true) errortest.AssertError(t, err, os.ErrNotExist) assert.Empty(t, result, "Expected no results when directory does not exist") }) } } -func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { +func TestLsRecursiveWithExclusionPatternsAndLimits(t *testing.T) { for _, fsType := range FileSystemTypes { t.Run("Test LsRecursiveWithExtensionPatternsAndLimits includes directories with enough max depth and enough max file count", func(t *testing.T) { fs := NewFs(fsType) @@ -2199,7 +2199,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { require.NoError(t, err) limits := &Limits{MaxDepth: 4, MaxFileCount: 10, Recursive: true} - results, err := fs.LsRecursiveWithExtensionPatternsAndLimits(context.Background(), rootDir, limits, true) + results, err := fs.LsRecursiveWithExclusionPatternsAndLimits(context.Background(), rootDir, limits, true) require.NoError(t, err) expectedFiles := []string{ filepath.Join(rootDir, "dir2", "dir3", "dir4", "test1.txt"), @@ -2226,7 +2226,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { require.NoError(t, err) limits := &Limits{MaxDepth: 4, MaxFileCount: 10, Recursive: true} - results, err := fs.LsRecursiveWithExtensionPatternsAndLimits(context.Background(), rootDir, limits, false) + results, err := fs.LsRecursiveWithExclusionPatternsAndLimits(context.Background(), rootDir, limits, false) require.NoError(t, err) expectedFiles := []string{ filepath.Join(rootDir, "dir2", "dir3", "dir4", "test1.txt"), @@ -2252,7 +2252,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { } limits := &Limits{MaxDepth: 4, MaxFileCount: 5, Recursive: true} - results, err := fs.LsRecursiveWithExtensionPatternsAndLimits(context.Background(), rootDir, limits, false, exclusionPatterns...) + results, err := fs.LsRecursiveWithExclusionPatternsAndLimits(context.Background(), rootDir, limits, false, exclusionPatterns...) require.NoError(t, err) expectedFiles := []string{ filepath.Join(rootDir, "dir2", "dir3", "dir4", "test1.txt"), @@ -2271,7 +2271,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { require.NoError(t, err) limits := &Limits{MaxDepth: 3, MaxFileCount: 5, Recursive: true} - results, err := fs.LsRecursiveWithExtensionPatternsAndLimits(context.Background(), rootDir, limits, false) + results, err := fs.LsRecursiveWithExclusionPatternsAndLimits(context.Background(), rootDir, limits, false) expectedFiles := []string{ filepath.Join(rootDir, "dir2", "dir5", "test4.txt"), filepath.Join(rootDir, "dir2", "dir5", "test5.jar"), @@ -2289,7 +2289,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { require.NoError(t, err) limits := &Limits{MaxDepth: 4, MaxFileCount: 2, Recursive: true} - results, err := fs.LsRecursiveWithExtensionPatternsAndLimits(context.Background(), rootDir, limits, false) + results, err := fs.LsRecursiveWithExclusionPatternsAndLimits(context.Background(), rootDir, limits, false) expectedFilesSize := 2 assert.Equal(t, expectedFilesSize, len(results)) @@ -2303,7 +2303,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { err := generateTestTree(fs, rootDir) require.NoError(t, err) - results, err := fs.LsRecursiveWithExtensionPatternsAndLimits(context.Background(), rootDir, nil, true) + results, err := fs.LsRecursiveWithExclusionPatternsAndLimits(context.Background(), rootDir, nil, true) errortest.AssertError(t, err, commonerrors.ErrUndefined) assert.Empty(t, results) @@ -2320,7 +2320,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { cancel() limits := &Limits{MaxDepth: 4, MaxFileCount: 5, Recursive: true} - result, err := fs.LsRecursiveWithExtensionPatternsAndLimits(ctx, rootDir, limits, true) + result, err := fs.LsRecursiveWithExclusionPatternsAndLimits(ctx, rootDir, limits, true) errortest.AssertError(t, err, commonerrors.ErrCancelled, commonerrors.ErrTimeout) assert.Empty(t, result, "Expected no results when context is canceled") }) @@ -2331,7 +2331,7 @@ func TestLsRecursiveWithExtensionPatternsAndLimits(t *testing.T) { nonExistentDir := filepath.Join(t.TempDir(), "non_existent_dir") limits := &Limits{MaxDepth: 4, MaxFileCount: 5, Recursive: true} - result, err := fs.LsRecursiveWithExtensionPatternsAndLimits(context.Background(), nonExistentDir, limits, true) + result, err := fs.LsRecursiveWithExclusionPatternsAndLimits(context.Background(), nonExistentDir, limits, true) errortest.AssertError(t, err, os.ErrNotExist) assert.Empty(t, result, "Expected no results when directory does not exist") }) diff --git a/utils/filesystem/interfaces.go b/utils/filesystem/interfaces.go index abd4dbe6fd..37545427e9 100644 --- a/utils/filesystem/interfaces.go +++ b/utils/filesystem/interfaces.go @@ -204,10 +204,10 @@ type FS interface { LsRecursive(ctx context.Context, dir string, includeDirectories bool) (files []string, err error) // LsWithExclusionPatterns lists all files and directory (equivalent to ls) but exclude the ones matching the exclusion patterns. LsWithExclusionPatterns(dir string, exclusionPatterns ...string) (files []string, err error) - // LsRecursiveWithExtensionPatterns lists all files recursively, including subdirectories but exclude the ones matching the exclusion patterns. - LsRecursiveWithExtensionPatterns(ctx context.Context, dir string, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) - // LsRecursiveWithExtensionPatternsAndLimits lists all files recursively, including subdirectories but exclude the ones matching the exclusion patterns and add some limits for recursion - LsRecursiveWithExtensionPatternsAndLimits(ctx context.Context, dir string, limit ILimits, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) + // LsRecursiveWithExclusionPatterns lists all files recursively, including subdirectories but exclude the ones matching the exclusion patterns. + LsRecursiveWithExclusionPatterns(ctx context.Context, dir string, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) + // LsRecursiveWithExclusionPatternsAndLimits lists all files recursively, including subdirectories but exclude the ones matching the exclusion patterns and add some limits for recursion + LsRecursiveWithExclusionPatternsAndLimits(ctx context.Context, dir string, limit ILimits, includeDirectories bool, exclusionPatterns ...string) (files []string, err error) // LsFromOpenedDirectory lists all files and directories (equivalent to ls) LsFromOpenedDirectory(dir File) (files []string, err error) // LsRecursiveFromOpenedDirectory lists all files recursively diff --git a/utils/mocks/mock_filesystem.go b/utils/mocks/mock_filesystem.go index 1a2769567e..69673d9f63 100644 --- a/utils/mocks/mock_filesystem.go +++ b/utils/mocks/mock_filesystem.go @@ -1732,44 +1732,44 @@ func (mr *MockFSMockRecorder) LsRecursiveFromOpenedDirectory(arg0, arg1, arg2 an return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveFromOpenedDirectory", reflect.TypeOf((*MockFS)(nil).LsRecursiveFromOpenedDirectory), arg0, arg1, arg2) } -// LsRecursiveWithExtensionPatterns mocks base method. -func (m *MockFS) LsRecursiveWithExtensionPatterns(arg0 context.Context, arg1 string, arg2 bool, arg3 ...string) ([]string, error) { +// LsRecursiveWithExclusionPatterns mocks base method. +func (m *MockFS) LsRecursiveWithExclusionPatterns(arg0 context.Context, arg1 string, arg2 bool, arg3 ...string) ([]string, error) { m.ctrl.T.Helper() varargs := []any{arg0, arg1, arg2} for _, a := range arg3 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "LsRecursiveWithExtensionPatterns", varargs...) + ret := m.ctrl.Call(m, "LsRecursiveWithExclusionPatterns", varargs...) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } -// LsRecursiveWithExtensionPatterns indicates an expected call of LsRecursiveWithExtensionPatterns. -func (mr *MockFSMockRecorder) LsRecursiveWithExtensionPatterns(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { +// LsRecursiveWithExclusionPatterns indicates an expected call of LsRecursiveWithExclusionPatterns. +func (mr *MockFSMockRecorder) LsRecursiveWithExclusionPatterns(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]any{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExtensionPatterns", reflect.TypeOf((*MockFS)(nil).LsRecursiveWithExtensionPatterns), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExclusionPatterns", reflect.TypeOf((*MockFS)(nil).LsRecursiveWithExclusionPatterns), varargs...) } -// LsRecursiveWithExtensionPatternsAndLimits mocks base method. -func (m *MockFS) LsRecursiveWithExtensionPatternsAndLimits(arg0 context.Context, arg1 string, arg2 filesystem.ILimits, arg3 bool, arg4 ...string) ([]string, error) { +// LsRecursiveWithExclusionPatternsAndLimits mocks base method. +func (m *MockFS) LsRecursiveWithExclusionPatternsAndLimits(arg0 context.Context, arg1 string, arg2 filesystem.ILimits, arg3 bool, arg4 ...string) ([]string, error) { m.ctrl.T.Helper() varargs := []any{arg0, arg1, arg2, arg3} for _, a := range arg4 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "LsRecursiveWithExtensionPatternsAndLimits", varargs...) + ret := m.ctrl.Call(m, "LsRecursiveWithExclusionPatternsAndLimits", varargs...) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } -// LsRecursiveWithExtensionPatternsAndLimits indicates an expected call of LsRecursiveWithExtensionPatternsAndLimits. -func (mr *MockFSMockRecorder) LsRecursiveWithExtensionPatternsAndLimits(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { +// LsRecursiveWithExclusionPatternsAndLimits indicates an expected call of LsRecursiveWithExclusionPatternsAndLimits. +func (mr *MockFSMockRecorder) LsRecursiveWithExclusionPatternsAndLimits(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExtensionPatternsAndLimits", reflect.TypeOf((*MockFS)(nil).LsRecursiveWithExtensionPatternsAndLimits), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExclusionPatternsAndLimits", reflect.TypeOf((*MockFS)(nil).LsRecursiveWithExclusionPatternsAndLimits), varargs...) } // LsWithExclusionPatterns mocks base method. @@ -3306,44 +3306,44 @@ func (mr *MockICloseableFSMockRecorder) LsRecursiveFromOpenedDirectory(arg0, arg return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveFromOpenedDirectory", reflect.TypeOf((*MockICloseableFS)(nil).LsRecursiveFromOpenedDirectory), arg0, arg1, arg2) } -// LsRecursiveWithExtensionPatterns mocks base method. -func (m *MockICloseableFS) LsRecursiveWithExtensionPatterns(arg0 context.Context, arg1 string, arg2 bool, arg3 ...string) ([]string, error) { +// LsRecursiveWithExclusionPatterns mocks base method. +func (m *MockICloseableFS) LsRecursiveWithExclusionPatterns(arg0 context.Context, arg1 string, arg2 bool, arg3 ...string) ([]string, error) { m.ctrl.T.Helper() varargs := []any{arg0, arg1, arg2} for _, a := range arg3 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "LsRecursiveWithExtensionPatterns", varargs...) + ret := m.ctrl.Call(m, "LsRecursiveWithExclusionPatterns", varargs...) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } -// LsRecursiveWithExtensionPatterns indicates an expected call of LsRecursiveWithExtensionPatterns. -func (mr *MockICloseableFSMockRecorder) LsRecursiveWithExtensionPatterns(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { +// LsRecursiveWithExclusionPatterns indicates an expected call of LsRecursiveWithExclusionPatterns. +func (mr *MockICloseableFSMockRecorder) LsRecursiveWithExclusionPatterns(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]any{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExtensionPatterns", reflect.TypeOf((*MockICloseableFS)(nil).LsRecursiveWithExtensionPatterns), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExclusionPatterns", reflect.TypeOf((*MockICloseableFS)(nil).LsRecursiveWithExclusionPatterns), varargs...) } -// LsRecursiveWithExtensionPatternsAndLimits mocks base method. -func (m *MockICloseableFS) LsRecursiveWithExtensionPatternsAndLimits(arg0 context.Context, arg1 string, arg2 filesystem.ILimits, arg3 bool, arg4 ...string) ([]string, error) { +// LsRecursiveWithExclusionPatternsAndLimits mocks base method. +func (m *MockICloseableFS) LsRecursiveWithExclusionPatternsAndLimits(arg0 context.Context, arg1 string, arg2 filesystem.ILimits, arg3 bool, arg4 ...string) ([]string, error) { m.ctrl.T.Helper() varargs := []any{arg0, arg1, arg2, arg3} for _, a := range arg4 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "LsRecursiveWithExtensionPatternsAndLimits", varargs...) + ret := m.ctrl.Call(m, "LsRecursiveWithExclusionPatternsAndLimits", varargs...) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } -// LsRecursiveWithExtensionPatternsAndLimits indicates an expected call of LsRecursiveWithExtensionPatternsAndLimits. -func (mr *MockICloseableFSMockRecorder) LsRecursiveWithExtensionPatternsAndLimits(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { +// LsRecursiveWithExclusionPatternsAndLimits indicates an expected call of LsRecursiveWithExclusionPatternsAndLimits. +func (mr *MockICloseableFSMockRecorder) LsRecursiveWithExclusionPatternsAndLimits(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExtensionPatternsAndLimits", reflect.TypeOf((*MockICloseableFS)(nil).LsRecursiveWithExtensionPatternsAndLimits), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LsRecursiveWithExclusionPatternsAndLimits", reflect.TypeOf((*MockICloseableFS)(nil).LsRecursiveWithExclusionPatternsAndLimits), varargs...) } // LsWithExclusionPatterns mocks base method.