Merge pull request #103 from shelltime/feat/issue-102-ignore-sections

feat(dotfile): add support for ignoring sections in collected files

Author: AnnatarHe

model/dotfile_apps.go

@@ -110,7 +110,12 @@ func (b *BaseApp) readFileContent(path string) (string, *time.Time, error) {
 	return string(content), &modTime, nil
 }
 
-func (b *BaseApp) CollectFromPaths(_ context.Context, appName string, paths []string) ([]DotfileItem, error) {
+func (b *BaseApp) CollectFromPaths(_ context.Context, appName string, paths []string, skipIgnoredSections *bool) ([]DotfileItem, error) {
+	// Default to true if not specified
+	shouldSkipIgnored := true
+	if skipIgnoredSections != nil {
+		shouldSkipIgnored = *skipIgnoredSections
+	}
 	hostname, _ := os.Hostname()
 	var dotfiles []DotfileItem
 
@@ -143,6 +148,11 @@ func (b *BaseApp) CollectFromPaths(_ context.Context, appName string, paths []st
 					continue
 				}
 
+				// Filter ignored sections if requested
+				if shouldSkipIgnored {
+					content = b.filterIgnoredSections(content)
+				}
+
 				dotfiles = append(dotfiles, DotfileItem{
 					App:            appName,
 					Path:           file,
@@ -160,6 +170,11 @@ func (b *BaseApp) CollectFromPaths(_ context.Context, appName string, paths []st
 				continue
 			}
 
+			// Filter ignored sections if requested
+			if shouldSkipIgnored {
+				content = b.filterIgnoredSections(content)
+			}
+
 			dotfiles = append(dotfiles, DotfileItem{
 				App:            appName,
 				Path:           expandedPath,
@@ -188,6 +203,32 @@ func (b *BaseApp) collectFromDirectory(dir string) ([]string, error) {
 	return files, err
 }
 
+// filterIgnoredSections removes content between SHELLTIME IGNORE BEGIN and SHELLTIME IGNORE END markers
+func (b *BaseApp) filterIgnoredSections(content string) string {
+	lines := strings.Split(content, "\n")
+	var filteredLines []string
+	var inIgnoreBlock bool
+
+	for _, line := range lines {
+		// Check for ignore markers (can be in comments)
+		if strings.Contains(line, "SHELLTIME IGNORE BEGIN") {
+			inIgnoreBlock = true
+			continue
+		}
+		if strings.Contains(line, "SHELLTIME IGNORE END") {
+			inIgnoreBlock = false
+			continue
+		}
+
+		// Only include lines that are not in an ignore block
+		if !inIgnoreBlock {
+			filteredLines = append(filteredLines, line)
+		}
+	}
+
+	return strings.Join(filteredLines, "\n")
+}
+
 // IsEqual checks if the provided files match the local files by comparing SHA256 hashes
 func (b *BaseApp) IsEqual(_ context.Context, files map[string]string) (map[string]bool, error) {
 	result := make(map[string]bool)

model/dotfile_apps_test.go

@@ -134,7 +134,8 @@ func TestBaseApp_CollectFromPaths(t *testing.T) {
 	require.NoError(t, err)
 
 	t.Run("collect from single file", func(t *testing.T) {
-		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{configFile})
+		skipIgnored := true
+		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{configFile}, &skipIgnored)
 		require.NoError(t, err)
 		assert.Len(t, dotfiles, 1)
 
@@ -148,7 +149,8 @@ func TestBaseApp_CollectFromPaths(t *testing.T) {
 	})
 
 	t.Run("collect from directory", func(t *testing.T) {
-		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{subDir})
+		skipIgnored := true
+		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{subDir}, &skipIgnored)
 		require.NoError(t, err)
 
 		// Should find 2 files (hidden files are ignored)
@@ -169,17 +171,58 @@ func TestBaseApp_CollectFromPaths(t *testing.T) {
 	})
 
 	t.Run("collect from mixed paths", func(t *testing.T) {
-		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{configFile, subDir})
+		skipIgnored := true
+		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{configFile, subDir}, &skipIgnored)
 		require.NoError(t, err)
 		assert.Len(t, dotfiles, 3) // 1 file + 2 files from directory
 	})
 
 	t.Run("collect from non-existent path", func(t *testing.T) {
 		nonExistentPath := filepath.Join(tmpDir, "does-not-exist")
-		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{nonExistentPath})
+		skipIgnored := true
+		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{nonExistentPath}, &skipIgnored)
 		require.NoError(t, err)
 		assert.Empty(t, dotfiles) // Should skip non-existent paths
 	})
+
+	t.Run("collect with ignored sections", func(t *testing.T) {
+		// Create a file with ignored sections
+		configWithIgnore := filepath.Join(tmpDir, "config_with_ignore.conf")
+		configContentWithIgnore := `line1
+# SHELLTIME IGNORE BEGIN
+secret_key=123456
+password=hidden
+# SHELLTIME IGNORE END
+line2
+visible_key=value`
+		err = os.WriteFile(configWithIgnore, []byte(configContentWithIgnore), 0644)
+		require.NoError(t, err)
+
+		// Test with skipIgnored = true (default behavior)
+		skipIgnored := true
+		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{configWithIgnore}, &skipIgnored)
+		require.NoError(t, err)
+		require.Len(t, dotfiles, 1)
+
+		// Should not contain ignored sections
+		assert.NotContains(t, dotfiles[0].Content, "secret_key")
+		assert.NotContains(t, dotfiles[0].Content, "password=hidden")
+		assert.NotContains(t, dotfiles[0].Content, "SHELLTIME IGNORE")
+		assert.Contains(t, dotfiles[0].Content, "line1")
+		assert.Contains(t, dotfiles[0].Content, "line2")
+		assert.Contains(t, dotfiles[0].Content, "visible_key=value")
+
+		// Test with skipIgnored = false
+		skipIgnored = false
+		dotfiles, err = app.CollectFromPaths(ctx, "testapp", []string{configWithIgnore}, &skipIgnored)
+		require.NoError(t, err)
+		require.Len(t, dotfiles, 1)
+
+		// Should contain all content including ignored sections
+		assert.Contains(t, dotfiles[0].Content, "secret_key")
+		assert.Contains(t, dotfiles[0].Content, "password=hidden")
+		assert.Contains(t, dotfiles[0].Content, "SHELLTIME IGNORE")
+	})
 }
 
 func TestBaseApp_collectFromDirectory(t *testing.T) {
@@ -524,7 +567,8 @@ func TestBaseApp_Integration(t *testing.T) {
 
 	t.Run("full workflow", func(t *testing.T) {
 		// 1. Collect dotfiles
-		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{configFile, subDir})
+		skipIgnored := true
+		dotfiles, err := app.CollectFromPaths(ctx, "testapp", []string{configFile, subDir}, &skipIgnored)
 		require.NoError(t, err)
 		assert.Len(t, dotfiles, 2)
 

model/dotfile_bash.go

@@ -25,5 +25,6 @@ func (b *BashApp) GetConfigPaths() []string {
 }
 
 func (b *BashApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return b.CollectFromPaths(ctx, b.Name(), b.GetConfigPaths())
+	skipIgnored := true
+	return b.CollectFromPaths(ctx, b.Name(), b.GetConfigPaths(), &skipIgnored)
 }

model/dotfile_claude.go

@@ -23,5 +23,6 @@ func (c *ClaudeApp) GetConfigPaths() []string {
 }
 
 func (c *ClaudeApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return c.CollectFromPaths(ctx, c.Name(), c.GetConfigPaths())
+	skipIgnored := true
+	return c.CollectFromPaths(ctx, c.Name(), c.GetConfigPaths(), &skipIgnored)
 }

model/dotfile_fish.go

@@ -24,5 +24,6 @@ func (f *FishApp) GetConfigPaths() []string {
 }
 
 func (f *FishApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return f.CollectFromPaths(ctx, f.Name(), f.GetConfigPaths())
+	skipIgnored := true
+	return f.CollectFromPaths(ctx, f.Name(), f.GetConfigPaths(), &skipIgnored)
 }

model/dotfile_ghostty.go

@@ -23,5 +23,6 @@ func (g *GhosttyApp) GetConfigPaths() []string {
 }
 
 func (g *GhosttyApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return g.CollectFromPaths(ctx, g.Name(), g.GetConfigPaths())
+	skipIgnored := true
+	return g.CollectFromPaths(ctx, g.Name(), g.GetConfigPaths(), &skipIgnored)
 }

model/dotfile_git.go

@@ -25,5 +25,6 @@ func (g *GitApp) GetConfigPaths() []string {
 }
 
 func (g *GitApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return g.CollectFromPaths(ctx, g.Name(), g.GetConfigPaths())
+	skipIgnored := true
+	return g.CollectFromPaths(ctx, g.Name(), g.GetConfigPaths(), &skipIgnored)
 }

model/dotfile_kitty.go

@@ -22,5 +22,6 @@ func (k *KittyApp) GetConfigPaths() []string {
 }
 
 func (k *KittyApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return k.CollectFromPaths(ctx, k.Name(), k.GetConfigPaths())
+	skipIgnored := true
+	return k.CollectFromPaths(ctx, k.Name(), k.GetConfigPaths(), &skipIgnored)
 }

model/dotfile_kubernetes.go

@@ -22,5 +22,6 @@ func (k *KubernetesApp) GetConfigPaths() []string {
 }
 
 func (k *KubernetesApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return k.CollectFromPaths(ctx, k.Name(), k.GetConfigPaths())
+	skipIgnored := true
+	return k.CollectFromPaths(ctx, k.Name(), k.GetConfigPaths(), &skipIgnored)
 }

model/dotfile_npm.go

@@ -22,5 +22,6 @@ func (n *NpmApp) GetConfigPaths() []string {
 }
 
 func (n *NpmApp) CollectDotfiles(ctx context.Context) ([]DotfileItem, error) {
-	return n.CollectFromPaths(ctx, n.Name(), n.GetConfigPaths())
+	skipIgnored := true
+	return n.CollectFromPaths(ctx, n.Name(), n.GetConfigPaths(), &skipIgnored)
 }