Merge pull request #2540 from keboola/mvasko/PSGO-198-kbcignore-branch-ignore

feat(.kbcignore): support ignoring whole branches

Author: Matovidlo

internal/pkg/project/ignore/file_test.go

@@ -29,6 +29,16 @@ func Test_loadFile(t *testing.T) {
 	assert.Equal(t, "keboola.bar/678/34\nkeboola.foo/345", file.rawStringPattern)
 }
 
+func newTestRegistryWithSlashBranch(t *testing.T) *registry.Registry {
+	t.Helper()
+	r := registry.New(knownpaths.NewNop(t.Context()), naming.NewRegistry(), model.NewComponentsMap(nil), model.SortByPath)
+	require.NoError(t, r.Set(&model.BranchState{
+		BranchManifest: &model.BranchManifest{BranchKey: model.BranchKey{ID: 789}},
+		Local:          &model.Branch{Name: "feature/foo"},
+	}))
+	return r
+}
+
 func newTestRegistry(t *testing.T) *registry.Registry {
 	t.Helper()
 

internal/pkg/project/ignore/ignore.go

@@ -36,11 +36,17 @@ func (f *File) parseIgnoredPatterns() []string {
 
 // applyIgnorePattern applies a single ignore pattern, marking the appropriate config or row as ignored.
 func (f *File) applyIgnorePattern(ignoreConfig string) error {
-	parts := strings.Split(ignoreConfig, "/")
+	// Branch pattern: "branch/<name>" — name may itself contain "/".
+	if strings.HasPrefix(ignoreConfig, "branch/") {
+		branchName := strings.TrimPrefix(ignoreConfig, "branch/")
+		f.state.IgnoreBranch(branchName)
+		return nil
+	}
 
+	parts := strings.Split(ignoreConfig, "/")
 	switch len(parts) {
 	case 2:
-		// Ignore config by ID and name.
+		// Ignore config by componentID/configID.
 		configID, componentID := parts[1], parts[0]
 		f.state.IgnoreConfig(configID, componentID)
 	case 3:

internal/pkg/project/ignore/ignore_test.go

@@ -31,6 +31,46 @@ func TestFile_IgnoreConfigsOrRows(t *testing.T) {
 	assert.Equal(t, "345", registry.IgnoredConfigs()[0].ID.String())
 }
 
+func TestFile_IgnoreConfigsOrRows_Branch(t *testing.T) {
+	t.Parallel()
+
+	ctx := t.Context()
+	r := newTestRegistry(t)
+	fs := aferofs.NewMemoryFs()
+
+	require.NoError(t, fs.WriteFile(ctx, filesystem.NewRawFile(`foo/bar1`, "branch/Main")))
+
+	file, err := LoadFile(ctx, fs, r, "foo/bar1")
+	require.NoError(t, err)
+
+	require.NoError(t, file.IgnoreConfigsOrRows())
+
+	ignored := r.IgnoredBranches()
+	require.Len(t, ignored, 1)
+	assert.Equal(t, "123", ignored[0].ID.String())
+}
+
+func TestFile_IgnoreConfigsOrRows_BranchWithSlashInName(t *testing.T) {
+	t.Parallel()
+
+	ctx := t.Context()
+	r := newTestRegistryWithSlashBranch(t)
+	fs := aferofs.NewMemoryFs()
+
+	require.NoError(t, fs.WriteFile(ctx, filesystem.NewRawFile(`foo/bar1`, "branch/feature/foo")))
+
+	file, err := LoadFile(ctx, fs, r, "foo/bar1")
+	require.NoError(t, err)
+
+	require.NoError(t, file.IgnoreConfigsOrRows())
+
+	// Branch "feature/foo" should be ignored, not misidentified as a config-row pattern.
+	ignored := r.IgnoredBranches()
+	require.Len(t, ignored, 1)
+	assert.Equal(t, "789", ignored[0].ID.String())
+	assert.Empty(t, r.IgnoredConfigRows())
+}
+
 func Test_applyIgnoredPatterns(t *testing.T) {
 	t.Parallel()
 	projectState := newTestRegistry(t)
@@ -83,6 +123,20 @@ func Test_applyIgnoredPatterns(t *testing.T) {
 			},
 			wantErr: assert.NoError,
 		},
+		{
+			name: "branch pattern",
+			args: args{
+				pattern: "branch/Main",
+			},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "branch pattern with slash in name",
+			args: args{
+				pattern: "branch/feature/foo",
+			},
+			wantErr: assert.NoError,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

internal/pkg/state/registry/registry.go

@@ -150,6 +150,59 @@ func (s *Registry) Configs() (configs []*model.ConfigState) {
 	return configs
 }
 
+func (s *Registry) IgnoreBranch(branchName string) {
+	for _, branch := range s.Branches() {
+		if branch.LocalOrRemoteState().(*model.Branch).Name == branchName {
+			branch.Ignore = true
+		}
+	}
+}
+
+func (s *Registry) IgnoredBranches() (branches []*model.BranchState) {
+	for _, branch := range s.Branches() {
+		if branch.Ignore {
+			branches = append(branches, branch)
+		}
+	}
+	return branches
+}
+
+// NullIgnoredBranchStates nulls local+remote state for every ignored branch and for all
+// configs/rows belonging to those branches, using a single pass over All() to avoid
+// repeated sorts.
+func (s *Registry) NullIgnoredBranchStates() {
+	ignored := s.IgnoredBranches()
+	if len(ignored) == 0 {
+		return
+	}
+
+	// Build set of ignored branch keys for O(1) lookup.
+	ignoredKeys := make(map[model.BranchKey]struct{}, len(ignored))
+	for _, b := range ignored {
+		ignoredKeys[b.BranchKey] = struct{}{}
+	}
+
+	for _, obj := range s.All() {
+		switch v := obj.(type) {
+		case *model.BranchState:
+			if _, ok := ignoredKeys[v.BranchKey]; ok {
+				v.SetLocalState(nil)
+				v.SetRemoteState(nil)
+			}
+		case *model.ConfigState:
+			if _, ok := ignoredKeys[model.BranchKey{ID: v.BranchID}]; ok {
+				v.SetLocalState(nil)
+				v.SetRemoteState(nil)
+			}
+		case *model.ConfigRowState:
+			if _, ok := ignoredKeys[model.BranchKey{ID: v.BranchID}]; ok {
+				v.SetLocalState(nil)
+				v.SetRemoteState(nil)
+			}
+		}
+	}
+}
+
 func (s *Registry) IgnoreConfig(ignoreID string, componentID string) {
 	for _, object := range s.All() {
 		if v, ok := object.(*model.ConfigState); ok {

internal/pkg/state/registry/registry_test.go

@@ -228,6 +228,50 @@ func TestRegistry_GetByPath(t *testing.T) {
 	assert.True(t, found)
 }
 
+func TestNullIgnoredBranchStates(t *testing.T) {
+	t.Parallel()
+	s := newTestState(t, knownpaths.NewNop(t.Context()))
+
+	// Initially all 6 objects (2 branches, 2 configs, 2 rows) are present.
+	assert.Len(t, s.All(), 6)
+
+	// Ignore the "Main" branch (ID 123).
+	s.IgnoreBranch("Main")
+	s.NullIgnoredBranchStates()
+
+	// Branch 123, its 2 configs, and 2 config rows are now invisible (both states nil).
+	// Only branch 567 remains.
+	assert.Len(t, s.All(), 1)
+	assert.Equal(t, BranchKey{ID: 567}, s.Branches()[0].BranchKey)
+	assert.Empty(t, s.Configs())
+	assert.Empty(t, s.ConfigRows())
+}
+
+func TestIgnoreBranch(t *testing.T) {
+	t.Parallel()
+	s := newTestState(t, knownpaths.NewNop(t.Context()))
+
+	// Before ignoring, no branches are ignored.
+	assert.Empty(t, s.IgnoredBranches())
+
+	// Ignore branch "Main" (ID 123).
+	s.IgnoreBranch("Main")
+
+	// Only the "Main" branch is ignored.
+	ignored := s.IgnoredBranches()
+	require.Len(t, ignored, 1)
+	assert.Equal(t, BranchKey{ID: 123}, ignored[0].BranchKey)
+
+	// "Foo Bar Branch" (ID 567) is not affected.
+	allBranches := s.Branches()
+	require.Len(t, allBranches, 2)
+	for _, b := range allBranches {
+		if b.ID == 567 {
+			assert.False(t, b.Ignore)
+		}
+	}
+}
+
 func newTestState(t *testing.T, paths *knownpaths.Paths) *Registry {
 	t.Helper()
 	registry := New(paths, naming.NewRegistry(), NewComponentsMap(nil), SortByPath)

pkg/lib/operation/project/sync/pull/operation.go

@@ -63,7 +63,7 @@ func Run(ctx context.Context, projectState *project.State, o Options, d dependen
 			return err
 		}
 
-		ignoreConfigsAndRows(projectState)
+		ignoreBranchesConfigsAndRows(projectState)
 	}
 
 	// Diff
@@ -156,12 +156,15 @@ func Run(ctx context.Context, projectState *project.State, o Options, d dependen
 	return nil
 }
 
-func ignoreConfigsAndRows(projectState *project.State) {
+func ignoreBranchesConfigsAndRows(projectState *project.State) {
 	for _, v := range projectState.IgnoredConfigRows() {
 		v.SetRemoteState(nil)
 	}
 
 	for _, v := range projectState.IgnoredConfigs() {
 		v.SetRemoteState(nil)
 	}
+
+	// Null both states for ignored branches so they are invisible to the diff.
+	projectState.NullIgnoredBranchStates()
 }

pkg/lib/operation/project/sync/push/operation.go

@@ -78,6 +78,9 @@ func Run(ctx context.Context, projectState *project.State, o Options, d dependen
 		if err = file.IgnoreConfigsOrRows(); err != nil {
 			return err
 		}
+
+		// Make ignored branches invisible to the push diff.
+		projectState.NullIgnoredBranchStates()
 	}
 
 	// Diff

test/cli/pull/ignore-branch/args

@@ -0,0 +1 @@
+pull --verbose --storage-api-token %%TEST_KBC_STORAGE_API_TOKEN%%

test/cli/pull/ignore-branch/expected-code

@@ -0,0 +1 @@
+0

test/cli/pull/ignore-branch/expected-stderr

@@ -0,0 +1 @@
+