From d9fd1456f8658a21f316e2ea3aed037ca719c6ba Mon Sep 17 00:00:00 2001
From: Dominik Przybyl <dominik.przybyl@vml.com>
Date: Thu, 12 Sep 2024 20:36:20 +0200
Subject: [PATCH] refactor content sync

---
 cmd/aem/content.go                      |  66 ++++++--
 cmd/aem/package.go                      |   6 +-
 pkg/common/pathx/pathx.go               |   4 +-
 pkg/content/content.go                  | 207 ++----------------------
 pkg/content_manager.go                  |  88 ++++------
 pkg/oak_run.go                          |   4 +-
 pkg/package_manager.go                  |  61 +++----
 pkg/pkg/vault/META-INF/vault/filter.xml |   7 +-
 pkg/test/clear_file_test.go             |  23 +++
 pkg/test/filter_file_test.go            |  39 +++++
 pkg/test/filter_root_test.go            |  37 +++++
 pkg/test/output.go                      |   6 +
 pkg/test/output/exclude_patterns.xml    |   7 +
 pkg/test/output/filter_roots.xml        |   5 +
 14 files changed, 255 insertions(+), 305 deletions(-)
 create mode 100644 pkg/test/clear_file_test.go
 create mode 100644 pkg/test/filter_file_test.go
 create mode 100644 pkg/test/filter_root_test.go
 create mode 100644 pkg/test/output.go
 create mode 100644 pkg/test/output/exclude_patterns.xml
 create mode 100644 pkg/test/output/filter_roots.xml

diff --git a/cmd/aem/content.go b/cmd/aem/content.go
index ca30329b..48490511 100644
--- a/cmd/aem/content.go
+++ b/cmd/aem/content.go
@@ -6,6 +6,8 @@ import (
 	"github.com/wttech/aemc/pkg"
 	"github.com/wttech/aemc/pkg/common/pathx"
 	"github.com/wttech/aemc/pkg/content"
+	"os"
+	"path/filepath"
 	"strings"
 )
 
@@ -74,7 +76,7 @@ func (c *CLI) contentDownloadCmd() *cobra.Command {
 			}
 			pid, _ := cmd.Flags().GetString("pid")
 			targetFile, _ := cmd.Flags().GetString("target-file")
-			filterRoots, _ := cmd.Flags().GetStringSlice("filter-roots")
+			filterRoots := determineFilterRoots(cmd)
 			filterFile, _ := cmd.Flags().GetString("filter-file")
 			if err = instance.ContentManager().Download(targetFile, pkg.PackageCreateOpts{
 				PID:         pid,
@@ -108,8 +110,6 @@ func (c *CLI) contentPullCmd() *cobra.Command {
 				c.Error(err)
 				return
 			}
-			clean, _ := cmd.Flags().GetBool("clean")
-			replace, _ := cmd.Flags().GetBool("replace")
 			dir, err := determineContentDir(cmd)
 			if err != nil {
 				c.Error(err)
@@ -120,13 +120,15 @@ func (c *CLI) contentPullCmd() *cobra.Command {
 				c.Error(err)
 				return
 			}
+			filterRoots := determineFilterRoots(cmd)
+			filterFile, _ := cmd.Flags().GetString("filter-file")
+			excludePatterns := determineExcludePatterns(cmd)
+			clean, _ := cmd.Flags().GetBool("clean")
+			replace, _ := cmd.Flags().GetBool("replace")
 			if dir != "" {
-				filterRoots, _ := cmd.Flags().GetStringSlice("filter-roots")
-				filterFile, _ := cmd.Flags().GetString("filter-file")
 				if err = instance.ContentManager().PullDir(dir, clean, replace, pkg.PackageCreateOpts{
 					FilterRoots: filterRoots,
 					FilterFile:  filterFile,
-					ContentDir:  dir,
 				}); err != nil {
 					c.Error(err)
 					return
@@ -134,7 +136,8 @@ func (c *CLI) contentPullCmd() *cobra.Command {
 				c.SetOutput("dir", dir)
 			} else if file != "" {
 				if err = instance.ContentManager().PullFile(file, clean, pkg.PackageCreateOpts{
-					ContentFile: file,
+					FilterRoots:     filterRoots,
+					ExcludePatterns: excludePatterns,
 				}); err != nil {
 					c.Error(err)
 					return
@@ -172,7 +175,7 @@ func (c *CLI) contentCopyCmd() *cobra.Command {
 				c.Error(err)
 				return
 			}
-			filterRoots, _ := cmd.Flags().GetStringSlice("filter-roots")
+			filterRoots := determineFilterRoots(cmd)
 			filterFile, _ := cmd.Flags().GetString("filter-file")
 			clean, _ := cmd.Flags().GetBool("clean")
 			if err = instance.ContentManager().Copy(targetInstance, clean, pkg.PackageCreateOpts{
@@ -221,7 +224,7 @@ func determineContentDir(cmd *cobra.Command) (string, error) {
 		return "", fmt.Errorf("content path '%s' does not contain '%s'", path, content.JCRRoot)
 	}
 	if path != "" && !pathx.Exists(path) {
-		return "", fmt.Errorf("content path does not exist: %s", path)
+		return "", fmt.Errorf("content path '%s' need to exist on file system; consider using 'dir' or 'file' parameter otherwise", path)
 	}
 	if path != "" && pathx.IsDir(path) {
 		return path, nil
@@ -239,10 +242,53 @@ func determineContentFile(cmd *cobra.Command) (string, error) {
 		return "", fmt.Errorf("content path '%s' does not contain '%s'", path, content.JCRRoot)
 	}
 	if path != "" && !pathx.Exists(path) {
-		return "", fmt.Errorf("content path does not exist: %s", path)
+		return "", fmt.Errorf("content path '%s' need to exist on file system; consider using 'dir' or 'file' parameter otherwise", path)
 	}
 	if path != "" && pathx.IsFile(path) {
 		return path, nil
 	}
 	return file, nil
 }
+
+func determineFilterRoots(cmd *cobra.Command) []string {
+	filterRoots, _ := cmd.Flags().GetStringSlice("filter-roots")
+	if len(filterRoots) > 0 {
+		return filterRoots
+	}
+	filterFile, _ := cmd.Flags().GetString("filter-file")
+	if filterFile != "" {
+		return nil
+	}
+	dir, _ := determineContentDir(cmd)
+	if dir != "" {
+		return []string{pkg.DetermineFilterRoot(dir)}
+	}
+	file, _ := determineContentFile(cmd)
+	if file != "" {
+		return []string{pkg.DetermineFilterRoot(file)}
+	}
+	return nil
+}
+
+func determineExcludePatterns(cmd *cobra.Command) []string {
+	file, _ := determineContentFile(cmd)
+	if file == "" || !strings.HasSuffix(file, content.JCRContentFile) {
+		return nil
+	}
+
+	dir := filepath.Dir(file)
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil
+	}
+
+	var excludePatterns []string
+	for _, entry := range entries {
+		if entry.Name() != content.JCRContentFile {
+			jcrPath := pkg.DetermineFilterRoot(filepath.Join(dir, entry.Name()))
+			excludePattern := fmt.Sprintf("%s(/.*)?", jcrPath)
+			excludePatterns = append(excludePatterns, excludePattern)
+		}
+	}
+	return excludePatterns
+}
diff --git a/cmd/aem/package.go b/cmd/aem/package.go
index 6911ed52..a96d7e23 100644
--- a/cmd/aem/package.go
+++ b/cmd/aem/package.go
@@ -506,8 +506,7 @@ func (c *CLI) pkgPathByFlags(cmd *cobra.Command) (string, error) {
 		path := c.aem.BaseOpts().TmpDir + "/package/" + fileName
 		if !pathx.Exists(path) {
 			log.Infof("downloading package from URL '%s' to file '%s'", url, path)
-			err := httpx.DownloadOnce(url, path)
-			if err != nil {
+			if err := httpx.DownloadOnce(url, path); err != nil {
 				return "", err
 			}
 			log.Infof("downloaded package from URL '%s' to file '%s'", url, path)
@@ -598,8 +597,7 @@ func (c *CLI) pkgUpdateCmd() *cobra.Command {
 				return
 			}
 			filterRoots, _ := cmd.Flags().GetStringSlice("filter-roots")
-			err = p.UpdateFilters(pkg.NewPackageFilters(filterRoots))
-			if err != nil {
+			if err = p.UpdateFilters(pkg.NewPackageFilters(filterRoots)); err != nil {
 				c.Error(err)
 				return
 			}
diff --git a/pkg/common/pathx/pathx.go b/pkg/common/pathx/pathx.go
index ac2a3543..00e938f8 100644
--- a/pkg/common/pathx/pathx.go
+++ b/pkg/common/pathx/pathx.go
@@ -202,10 +202,10 @@ func DirAndFileName(path string) (string, string) {
 
 func RandomDir(tmpDir string, prefix string) string {
 	suffix, _ := goutils.RandomNumeric(8)
-	return filepath.Join(tmpDir, prefix+"_"+suffix)
+	return Abs(filepath.Join(tmpDir, prefix+"_"+suffix))
 }
 
 func RandomFileName(tmpDir string, prefix string, extension string) string {
 	suffix, _ := goutils.RandomNumeric(8)
-	return filepath.Join(tmpDir, prefix+"_"+suffix+extension)
+	return Abs(filepath.Join(tmpDir, prefix+"_"+suffix+extension))
 }
diff --git a/pkg/content/content.go b/pkg/content/content.go
index f7955a94..fed2f8f8 100644
--- a/pkg/content/content.go
+++ b/pkg/content/content.go
@@ -9,7 +9,6 @@ import (
 	"github.com/wttech/aemc/pkg/base"
 	"github.com/wttech/aemc/pkg/common/pathx"
 	"github.com/wttech/aemc/pkg/common/stringsx"
-	"io"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -18,18 +17,13 @@ import (
 )
 
 const (
-	JCRRoot                   = "jcr_root"
-	JCRContentFile            = ".content.xml"
-	JCRContentFileSuffix      = ".xml"
-	JCRMixinTypesProp         = "jcr:mixinTypes"
-	JCRRootPrefix             = "<jcr:root"
-	PropPattern               = "^\\s*([^ =]+)=\"([^\"]+)\"(.*)$"
-	NamespacePattern          = "^\\w+:(\\w+)=\"[^\"]+\"$"
-	ParentsBackupSuffix       = ".bak"
-	ParentsBackupDirIndicator = ".bakdir"
-	JCRContentNode            = "jcr:content"
-	JCRContentPrefix          = "<jcr:content"
-	JCRContentDirName         = "_jcr_content"
+	JCRRoot           = "jcr_root"
+	JCRContentFile    = ".content.xml"
+	XmlFileSuffix     = ".xml"
+	JCRMixinTypesProp = "jcr:mixinTypes"
+	JCRRootPrefix     = "<jcr:root"
+	PropPattern       = "^\\s*([^ =]+)=\"([^\"]+)\"(.*)$"
+	NamespacePattern  = "^\\w+:(\\w+)=\"[^\"]+\"$"
 )
 
 var (
@@ -66,24 +60,12 @@ func NewManager(baseOpts *base.Opts) *Manager {
 	}
 }
 
-func (c Manager) Prepare(root string) error {
-	return deleteDir(root)
+func (c Manager) PrepareDir(dir string) error {
+	return deleteDir(dir)
 }
 
-func (c Manager) BeforePullDir(root string) error {
-	return c.doParentsBackup(root)
-}
-
-func (c Manager) BeforePullFile(path string) error {
-	return c.doSiblingsBackup(path)
-}
-
-func (c Manager) AfterPullDir(root string) error {
-	return c.undoParentsBackup(root)
-}
-
-func (c Manager) AfterPullFile(path string) error {
-	return c.undoSiblingBackup(path)
+func (c Manager) PrepareFile(file string) error {
+	return deleteFile(file, nil)
 }
 
 func (c Manager) CleanDir(root string) error {
@@ -125,21 +107,6 @@ func (c Manager) CleanFile(path string) error {
 	return nil
 }
 
-func eachFilesInDir(root string, processFileFunc func(path string) error) error {
-	entries, err := os.ReadDir(root)
-	if err != nil {
-		return err
-	}
-	for _, entry := range entries {
-		if !entry.IsDir() {
-			if err = processFileFunc(filepath.Join(root, entry.Name())); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 func eachFiles(root string, processFileFunc func(string) error) error {
 	return filepath.WalkDir(root, func(path string, entry fs.DirEntry, err error) error {
 		if entry.IsDir() {
@@ -156,7 +123,7 @@ func (c Manager) cleanDotContents(root string) error {
 }
 
 func (c Manager) cleanDotContentFile(path string) error {
-	if !strings.HasSuffix(path, JCRContentFileSuffix) {
+	if !strings.HasSuffix(path, XmlFileSuffix) {
 		return nil
 	}
 
@@ -269,23 +236,11 @@ func (c Manager) flattenFile(path string) error {
 }
 
 func (c Manager) deleteFiles(root string) error {
-	if err := eachParentFiles(root, func(parent string) error {
-		return eachFilesInDir(parent, func(path string) error {
-			return deleteFile(path, func() bool {
-				return matchAnyRule(path, path, c.FilesDeleted)
-			})
-		})
-	}); err != nil {
-		return err
-	}
-	if err := eachFiles(root, func(path string) error {
+	return eachFiles(root, func(path string) error {
 		return deleteFile(path, func() bool {
 			return matchAnyRule(path, path, c.FilesDeleted)
 		})
-	}); err != nil {
-		return err
-	}
-	return nil
+	})
 }
 
 func deleteDir(dir string) error {
@@ -329,96 +284,6 @@ func deleteEmptyDirs(root string) error {
 	return nil
 }
 
-func (c Manager) doParentsBackup(root string) error {
-	return eachParentFiles(root, func(parent string) error {
-		if err := createBackupIndicator(parent); err != nil {
-			return err
-		}
-		return eachFilesInDir(parent, func(path string) error {
-			if !strings.HasSuffix(path, ParentsBackupSuffix) && !strings.HasSuffix(path, ParentsBackupDirIndicator) {
-				log.Infof("doing backup of parent file '%s'", path)
-				if err := c.backupFile(path); err != nil {
-					return err
-				}
-			}
-			return nil
-		})
-	})
-}
-
-func (c Manager) doSiblingsBackup(file string) error {
-	dir := filepath.Dir(file)
-	if err := createBackupIndicator(dir); err != nil {
-		return err
-	}
-	return eachFilesInDir(dir, func(path string) error {
-		if path != file && !strings.HasSuffix(path, ParentsBackupSuffix) && !strings.HasSuffix(path, ParentsBackupDirIndicator) {
-			log.Infof("doing backup of file '%s'", path)
-			if err := c.backupFile(path); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}
-
-func (c Manager) undoParentsBackup(root string) error {
-	return eachParentFiles(root, func(parent string) error {
-		indicator := false
-		if err := eachFilesInDir(parent, func(path string) error {
-			indicator = indicator || strings.HasSuffix(path, ParentsBackupDirIndicator)
-			return nil
-		}); err != nil {
-			return err
-		}
-		if !indicator {
-			return nil
-		}
-
-		if err := eachFilesInDir(parent, func(path string) error {
-			return deleteFile(path, func() bool {
-				return !strings.HasSuffix(path, ParentsBackupSuffix)
-			})
-		}); err != nil {
-			return err
-		}
-
-		return eachFilesInDir(parent, func(path string) error {
-			if strings.HasSuffix(path, ParentsBackupSuffix) {
-				origin := strings.TrimSuffix(path, ParentsBackupSuffix)
-				log.Infof("undoing backup of parent file '%s'", path)
-				return os.Rename(path, origin)
-			}
-			return nil
-		})
-	})
-}
-
-func (c Manager) undoSiblingBackup(path string) error {
-	dir := filepath.Dir(path)
-	return eachFilesInDir(dir, func(path string) error {
-		if strings.HasSuffix(path, ParentsBackupSuffix) {
-			origin := strings.TrimSuffix(path, ParentsBackupSuffix)
-			log.Infof("undoing backup of file '%s'", path)
-			return os.Rename(path, origin)
-		} else if strings.HasSuffix(path, ParentsBackupDirIndicator) {
-			return deleteFile(path, nil)
-		}
-		return nil
-	})
-}
-
-func eachParentFiles(root string, processFileFunc func(string) error) error {
-	parent := root
-	for strings.Contains(parent, JCRRoot) && filepath.Base(parent) != JCRRoot {
-		parent = filepath.Dir(parent)
-		if err := processFileFunc(parent); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func matchAnyRule(value string, path string, rules []PathRule) bool {
 	return lo.SomeBy(rules, func(rule PathRule) bool {
 		return matchRule(value, path, rule)
@@ -469,32 +334,6 @@ func writeLines(path string, lines []string) error {
 	return err
 }
 
-func createBackupIndicator(dir string) error {
-	indicator, err := os.Create(filepath.Join(dir, ParentsBackupDirIndicator))
-	defer func() { _ = indicator.Close() }()
-	return err
-}
-
-func (c Manager) backupFile(path string) error {
-	source, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = source.Close() }()
-
-	destination, err := os.Create(path + ParentsBackupSuffix)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = destination.Close() }()
-
-	_, err = io.Copy(destination, source)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
 type PathRule struct {
 	Patterns      []string
 	ExcludedPaths []string
@@ -521,21 +360,3 @@ func determineStringSlice(values any, key string) []string {
 	}
 	return result
 }
-
-func IsContentFile(path string) bool {
-	if !strings.HasSuffix(path, JCRContentFile) {
-		return false
-	}
-
-	inputLines, err := readLines(path)
-	if err != nil {
-		return false
-	}
-
-	for _, inputLine := range inputLines {
-		if strings.Contains(inputLine, JCRContentPrefix) {
-			return true
-		}
-	}
-	return false
-}
diff --git a/pkg/content_manager.go b/pkg/content_manager.go
index 674f2ec9..1ea4331c 100644
--- a/pkg/content_manager.go
+++ b/pkg/content_manager.go
@@ -36,6 +36,10 @@ func (cm *ContentManager) pkgMgr() *PackageManager {
 	return cm.instance.PackageManager()
 }
 
+func (cm *ContentManager) contentManager() *content.Manager {
+	return cm.instance.manager.aem.ContentManager()
+}
+
 func (cm *ContentManager) tmpDir() string {
 	if cm.instance.manager.aem.Detached() {
 		return os.TempDir()
@@ -51,9 +55,7 @@ func (cm *ContentManager) Download(localFile string, opts PackageCreateOpts) err
 	if err != nil {
 		return err
 	}
-	defer func() {
-		_ = cm.pkgMgr().Delete(remotePath)
-	}()
+	defer func() { _ = cm.pkgMgr().Delete(remotePath) }()
 	if err := cm.pkgMgr().Build(remotePath); err != nil {
 		return err
 	}
@@ -64,39 +66,29 @@ func (cm *ContentManager) Download(localFile string, opts PackageCreateOpts) err
 }
 
 func (cm *ContentManager) PullDir(dir string, clean bool, replace bool, opts PackageCreateOpts) error {
-	pkgFile := pathx.RandomFileName(cm.tmpDir(), "content_pull", ".zip")
-	if err := cm.Download(pkgFile, opts); err != nil {
-		return err
-	}
 	workDir := pathx.RandomDir(cm.tmpDir(), "content_pull")
+	pkgFile := pathx.RandomFileName(cm.tmpDir(), "content_pull", ".zip")
 	defer func() {
-		_ = pathx.DeleteIfExists(pkgFile)
 		_ = pathx.DeleteIfExists(workDir)
+		_ = pathx.DeleteIfExists(pkgFile)
 	}()
-	if err := content.Unzip(pkgFile, workDir); err != nil {
+	if err := cm.Download(pkgFile, opts); err != nil {
 		return err
 	}
-	if err := pathx.Ensure(dir); err != nil {
+	if err := content.Unzip(pkgFile, workDir); err != nil {
 		return err
 	}
-	before, _, _ := strings.Cut(dir, content.JCRRoot)
-	contentManager := cm.instance.manager.aem.contentManager
 	if replace {
-		if err := contentManager.Prepare(dir); err != nil {
+		if err := cm.contentManager().PrepareDir(dir); err != nil {
 			return err
 		}
 	}
-	if err := contentManager.BeforePullDir(dir); err != nil {
-		return err
-	}
-	if err := filex.CopyDir(filepath.Join(workDir, content.JCRRoot), filepath.Join(before, content.JCRRoot)); err != nil {
-		return err
-	}
-	if err := contentManager.AfterPullDir(dir); err != nil {
+	_, jcrPath, _ := strings.Cut(dir, content.JCRRoot)
+	if err := filex.CopyDir(filepath.Join(workDir, content.JCRRoot, jcrPath), dir); err != nil {
 		return err
 	}
 	if clean {
-		if err := contentManager.CleanDir(dir); err != nil {
+		if err := cm.contentManager().CleanDir(dir); err != nil {
 			return err
 		}
 	}
@@ -104,64 +96,52 @@ func (cm *ContentManager) PullDir(dir string, clean bool, replace bool, opts Pac
 }
 
 func (cm *ContentManager) PullFile(file string, clean bool, opts PackageCreateOpts) error {
-	pkgFile := pathx.RandomFileName(cm.tmpDir(), "content_pull", ".zip")
-	if err := cm.Download(pkgFile, opts); err != nil {
-		return err
-	}
 	workDir := pathx.RandomDir(cm.tmpDir(), "content_pull")
+	pkgFile := pathx.RandomFileName(cm.tmpDir(), "content_pull", ".zip")
 	defer func() {
-		_ = pathx.DeleteIfExists(pkgFile)
 		_ = pathx.DeleteIfExists(workDir)
+		_ = pathx.DeleteIfExists(pkgFile)
 	}()
-	if err := content.Unzip(pkgFile, workDir); err != nil {
-		return err
-	}
-	dir := filepath.Dir(file)
-	if err := pathx.Ensure(dir); err != nil {
+	if err := cm.Download(pkgFile, opts); err != nil {
 		return err
 	}
-	_, after, _ := strings.Cut(dir, content.JCRRoot)
-	contentManager := cm.instance.manager.aem.contentManager
-	if err := contentManager.BeforePullFile(file); err != nil {
+	if err := content.Unzip(pkgFile, workDir); err != nil {
 		return err
 	}
-	if err := filex.CopyDir(filepath.Join(workDir, content.JCRRoot, after), dir); err != nil {
-		return err
+	cleanFile := DetermineCleanFile(file)
+	if file != cleanFile {
+		if err := cm.contentManager().PrepareFile(file); err != nil {
+			return err
+		}
 	}
-	if err := contentManager.AfterPullFile(file); err != nil {
+	_, jcrPath, _ := strings.Cut(cleanFile, content.JCRRoot)
+	if err := filex.Copy(filepath.Join(workDir, content.JCRRoot, jcrPath), cleanFile, true); err != nil {
 		return err
 	}
 	if clean {
-		cleanFile := determineCleanFile(file)
-		if err := contentManager.CleanFile(cleanFile); err != nil {
+		if err := cm.contentManager().CleanFile(cleanFile); err != nil {
 			return err
 		}
-		if strings.HasSuffix(file, content.JCRContentFile) {
-			root := filepath.Join(dir, content.JCRContentDirName)
-			if pathx.Exists(root) {
-				if err := contentManager.CleanDir(root); err != nil {
-					return err
-				}
-			}
-		}
 	}
 	return nil
 }
 
-func determineCleanFile(file string) string {
+func DetermineCleanFile(file string) string {
 	if namespacePatternRegex.MatchString(file) && !strings.HasSuffix(file, content.JCRContentFile) {
-		return filepath.Join(strings.ReplaceAll(file, content.JCRContentFileSuffix, ""), content.JCRContentFile)
+		return filepath.Join(strings.ReplaceAll(file, content.XmlFileSuffix, ""), content.JCRContentFile)
 	}
 	return file
 }
 
 func (cm *ContentManager) Copy(destInstance *Instance, clean bool, opts PackageCreateOpts) error {
-	var pkgFile = pathx.RandomFileName(cm.tmpDir(), "content_copy", ".zip")
-	defer func() { _ = pathx.DeleteIfExists(pkgFile) }()
+	workDir := pathx.RandomDir(cm.tmpDir(), "content_copy")
+	pkgFile := pathx.RandomFileName(cm.tmpDir(), "content_copy", ".zip")
+	defer func() {
+		_ = pathx.DeleteIfExists(workDir)
+		_ = pathx.DeleteIfExists(pkgFile)
+	}()
 	if clean {
-		workDir := pathx.RandomDir(cm.tmpDir(), "content_copy")
-		defer func() { _ = pathx.DeleteIfExists(workDir) }()
-		if err := cm.PullDir(filepath.Join(workDir, content.JCRRoot), clean, false, opts); err != nil {
+		if err := cm.PullDir(filepath.Join(workDir, content.JCRRoot), true, false, opts); err != nil {
 			return err
 		}
 		if err := content.Zip(workDir, pkgFile); err != nil {
diff --git a/pkg/oak_run.go b/pkg/oak_run.go
index a1f419b7..034a1ac7 100644
--- a/pkg/oak_run.go
+++ b/pkg/oak_run.go
@@ -86,9 +86,7 @@ func (or OakRun) SetPassword(instanceDir string, user string, password string) e
 	if err := tplx.RenderFile(scriptFile, instance.OakRunSetPassword, map[string]any{"User": user, "Password": password}); err != nil {
 		return err
 	}
-	defer func() {
-		pathx.DeleteIfExists(scriptFile)
-	}()
+	defer func() { pathx.DeleteIfExists(scriptFile) }()
 	if err := or.RunScript(instanceDir, scriptFile); err != nil {
 		return err
 	}
diff --git a/pkg/package_manager.go b/pkg/package_manager.go
index ebd895ed..75b4268d 100644
--- a/pkg/package_manager.go
+++ b/pkg/package_manager.go
@@ -166,11 +166,10 @@ func copyPackageDefaultFiles(targetTmpDir string, data map[string]any) error {
 }
 
 type PackageCreateOpts struct {
-	PID         string
-	FilterRoots []string
-	FilterFile  string
-	ContentDir  string
-	ContentFile string
+	PID             string
+	FilterRoots     []string
+	FilterFile      string
+	ExcludePatterns []string
 }
 
 func (pm *PackageManager) Create(opts PackageCreateOpts) (string, error) {
@@ -186,21 +185,19 @@ func (pm *PackageManager) Create(opts PackageCreateOpts) (string, error) {
 		_ = pathx.DeleteIfExists(tmpDir)
 		_ = pathx.DeleteIfExists(tmpFile)
 	}()
-	if len(opts.FilterRoots) == 0 && opts.FilterFile == "" {
-		opts.FilterRoots = []string{determineFilterRoot(opts)}
-	}
 	data := map[string]any{
-		"Pid":         opts.PID,
-		"Group":       pidConfig.Group,
-		"Name":        pidConfig.Name,
-		"Version":     pidConfig.Version,
-		"FilterRoots": opts.FilterRoots,
+		"Pid":             opts.PID,
+		"Group":           pidConfig.Group,
+		"Name":            pidConfig.Name,
+		"Version":         pidConfig.Version,
+		"FilterRoots":     opts.FilterRoots,
+		"ExcludePatterns": opts.ExcludePatterns,
 	}
 	if err = copyPackageDefaultFiles(tmpDir, data); err != nil {
 		return "", err
 	}
 	if opts.FilterFile != "" {
-		if err = filex.Copy(opts.FilterFile, filepath.Join(tmpDir, "META-INF", "vault", FilterXML), true); err != nil {
+		if err = filex.Copy(opts.FilterFile, filepath.Join(tmpDir, pkg.MetaPath, pkg.VltDir, FilterXML), true); err != nil {
 			return "", err
 		}
 	}
@@ -227,33 +224,23 @@ func (pm *PackageManager) Create(opts PackageCreateOpts) (string, error) {
 	return status.Path, nil
 }
 
-func determineFilterRoot(opts PackageCreateOpts) string {
-	if opts.ContentDir != "" {
-		return strings.Split(opts.ContentDir, content.JCRRoot)[1]
-	}
-
-	if opts.ContentFile != "" {
-		contentFile := strings.Split(opts.ContentFile, content.JCRRoot)[1]
-		if content.IsContentFile(opts.ContentFile) {
-			return strings.ReplaceAll(contentFile, content.JCRContentFile, content.JCRContentNode)
-		} else if strings.HasSuffix(contentFile, content.JCRContentFile) {
-			contentFile = namespacePatternRegex.ReplaceAllString(contentFile, "$1:")
-			return filepath.Dir(contentFile)
-		} else if strings.HasSuffix(contentFile, content.JCRContentFileSuffix) {
-			contentFile = namespacePatternRegex.ReplaceAllString(contentFile, "$1:")
-			return strings.ReplaceAll(contentFile, content.JCRContentFileSuffix, "")
-		}
-		return contentFile
+func DetermineFilterRoot(path string) string {
+	_, filterRoot, _ := strings.Cut(path, content.JCRRoot)
+	filterRoot = strings.ReplaceAll(filterRoot, "\\", "/")
+	if strings.HasSuffix(path, content.JCRContentFile) {
+		filterRoot = filepath.Dir(filterRoot)
+	} else if strings.HasSuffix(path, content.XmlFileSuffix) {
+		filterRoot = strings.ReplaceAll(filterRoot, content.XmlFileSuffix, "")
 	}
-
-	return ""
+	filterRoot = namespacePatternRegex.ReplaceAllString(filterRoot, "/$2:")
+	filterRoot = strings.ReplaceAll(filterRoot, "/__", "/_")
+	filterRoot = strings.ReplaceAll(filterRoot, "%3a", ":")
+	return filterRoot
 }
 
 func (pm *PackageManager) Copy(remotePath string, destInstance *Instance) error {
-	var localPath = pathx.RandomFileName(pm.tmpDir(), "pkg_copy", ".zip")
-	defer func() {
-		_ = pathx.DeleteIfExists(localPath)
-	}()
+	localPath := pathx.RandomFileName(pm.tmpDir(), "pkg_copy", ".zip")
+	defer func() { _ = pathx.DeleteIfExists(localPath) }()
 	if err := pm.Download(remotePath, localPath); err != nil {
 		return err
 	}
diff --git a/pkg/pkg/vault/META-INF/vault/filter.xml b/pkg/pkg/vault/META-INF/vault/filter.xml
index 6508d599..66ec60cc 100644
--- a/pkg/pkg/vault/META-INF/vault/filter.xml
+++ b/pkg/pkg/vault/META-INF/vault/filter.xml
@@ -1,4 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<workspaceFilter version="1.0">[[range .FilterRoots]]
-    <filter root="[[.]]"/>[[end]]
+<workspaceFilter version="1.0">[[if .ExcludePatterns]]
+    <filter root="[[index .FilterRoots 0]]">[[range .ExcludePatterns]]
+        <exclude pattern="[[.]]"/>[[end]]
+    </filter>[[else]][[range .FilterRoots]]
+    <filter root="[[.]]"/>[[end]][[end]]
 </workspaceFilter>
diff --git a/pkg/test/clear_file_test.go b/pkg/test/clear_file_test.go
new file mode 100644
index 00000000..135a43ce
--- /dev/null
+++ b/pkg/test/clear_file_test.go
@@ -0,0 +1,23 @@
+package test
+
+import (
+	"github.com/wttech/aemc/pkg"
+	"testing"
+)
+
+func TestDetermineCleanFile(t *testing.T) {
+	tests := []struct {
+		path, expected string
+	}{
+		{"/somepath/jcr_root/content/my_file.xml", "/somepath/jcr_root/content/my_file.xml"},
+		{"/somepath/jcr_root/content/_cq_file.xml", "/somepath/jcr_root/content/_cq_file/.content.xml"},
+		{"/somepath/jcr_root/content/_cq_file/.content.xml", "/somepath/jcr_root/content/_cq_file/.content.xml"},
+		{"/somepath/jcr_root/content/.content.xml", "/somepath/jcr_root/content/.content.xml"},
+	}
+	for _, test := range tests {
+		actual := pkg.DetermineCleanFile(test.path)
+		if actual != test.expected {
+			t.Errorf("DetermineCleanFile(%s) = %s; want %s", test.path, actual, test.expected)
+		}
+	}
+}
diff --git a/pkg/test/filter_file_test.go b/pkg/test/filter_file_test.go
new file mode 100644
index 00000000..30c8c0a3
--- /dev/null
+++ b/pkg/test/filter_file_test.go
@@ -0,0 +1,39 @@
+package test
+
+import (
+	"github.com/wttech/aemc/pkg/common/tplx"
+	"github.com/wttech/aemc/pkg/pkg"
+	"testing"
+)
+
+func testFilterFile(t *testing.T, filterFile string, expectedFile string, data map[string]any) {
+	bytes, err := pkg.VaultFS.ReadFile(filterFile)
+	if err != nil {
+		t.Fatalf("%v %v", bytes, err)
+	}
+	expected, err := VaultFS.ReadFile(expectedFile)
+	if err != nil {
+		t.Fatalf("%v %v", bytes, err)
+	}
+	actual, err := tplx.RenderString(string(bytes), data)
+	if actual != string(expected) {
+		t.Errorf("RenderString(%s, %v) = %s; want %s", string(bytes), data, actual, expected)
+	}
+}
+
+func TestFilterRoots(t *testing.T) {
+	testFilterFile(t, "vault/META-INF/vault/filter.xml", "output/filter_roots.xml",
+		map[string]any{
+			"FilterRoots": []string{"/apps/my_site", "/content/my_site"},
+		},
+	)
+}
+
+func TestExcludePatterns(t *testing.T) {
+	testFilterFile(t, "vault/META-INF/vault/filter.xml", "output/exclude_patterns.xml",
+		map[string]any{
+			"FilterRoots":     []string{"/apps/my_site", "/content/my_site"},
+			"ExcludePatterns": []string{"/apps/my_site/cq:dialog(/.*)?", "/apps/my_site/rep:policy(/.*)?"},
+		},
+	)
+}
diff --git a/pkg/test/filter_root_test.go b/pkg/test/filter_root_test.go
new file mode 100644
index 00000000..922a8764
--- /dev/null
+++ b/pkg/test/filter_root_test.go
@@ -0,0 +1,37 @@
+package test
+
+import (
+	"github.com/wttech/aemc/pkg"
+	"testing"
+)
+
+func TestDetermineFilterRoot(t *testing.T) {
+	tests := []struct {
+		path, expected string
+	}{
+		{"/somepath/jcr_root/content/my_site", "/content/my_site"},
+		{"/somepath/jcr_root/content/my_site/_cq_path", "/content/my_site/cq:path"},
+		{"/somepath/jcr_root/content/my_site/_xmpBJ_path", "/content/my_site/xmpBJ:path"},
+		{"/somepath/jcr_root/content/my_site/_s7sitecatalyst_path", "/content/my_site/s7sitecatalyst:path"},
+		{"/somepath/jcr_root/content/my_site/adobe_dam%3apath", "/content/my_site/adobe_dam:path"},
+		{"/somepath/jcr_root/content/my_site/_cq__sub_path_", "/content/my_site/cq:_sub_path_"},
+		{"/somepath/jcr_root/content/my_site/__cq_path", "/content/my_site/_cq_path"},
+		{"/somepath/jcr_root/content/my_site/__abc_path", "/content/my_site/_abc_path"},
+		{"/somepath/jcr_root/content/my_site/__path", "/content/my_site/_path"},
+		{"/somepath/jcr_root/content/my_site/___path", "/content/my_site/__path"},
+		{"\\somepath\\jcr_root\\content\\my_site", "/content/my_site"},
+		{"\\somepath\\jcr_root\\content\\my_site\\_cq_path", "/content/my_site/cq:path"},
+		{"/somepath/jcr_root/content/my_app/_cq_dialog/.content.xml", "/content/my_app/cq:dialog"},
+		{"/somepath/jcr_root/content/my_app/_cq_dialog.xml", "/content/my_app/cq:dialog"},
+		{"/somepath/jcr_root/content/my_conf/workflow.xml", "/content/my_conf/workflow"},
+		{"/somepath/jcr_root/content/dam/my_site/image.png", "/content/dam/my_site/image.png"},
+		{"/somepath/jcr_root/conf/my_site/_sling_configs/com.config.ImageConfig", "/conf/my_site/sling:configs/com.config.ImageConfig"},
+		{"/somepath/jcr_root/conf/my_site/_sling_configs/com.config.ImageConfig/_jcr_content", "/conf/my_site/sling:configs/com.config.ImageConfig/jcr:content"},
+	}
+	for _, test := range tests {
+		actual := pkg.DetermineFilterRoot(test.path)
+		if actual != test.expected {
+			t.Errorf("DetermineFilterRoot(%s) = %s; want %s", test.path, actual, test.expected)
+		}
+	}
+}
diff --git a/pkg/test/output.go b/pkg/test/output.go
new file mode 100644
index 00000000..56a834e2
--- /dev/null
+++ b/pkg/test/output.go
@@ -0,0 +1,6 @@
+package test
+
+import "embed"
+
+//go:embed output
+var VaultFS embed.FS
diff --git a/pkg/test/output/exclude_patterns.xml b/pkg/test/output/exclude_patterns.xml
new file mode 100644
index 00000000..aa4ae2bb
--- /dev/null
+++ b/pkg/test/output/exclude_patterns.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<workspaceFilter version="1.0">
+    <filter root="/apps/my_site">
+        <exclude pattern="/apps/my_site/cq:dialog(/.*)?"/>
+        <exclude pattern="/apps/my_site/rep:policy(/.*)?"/>
+    </filter>
+</workspaceFilter>
diff --git a/pkg/test/output/filter_roots.xml b/pkg/test/output/filter_roots.xml
new file mode 100644
index 00000000..1c5aca1b
--- /dev/null
+++ b/pkg/test/output/filter_roots.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<workspaceFilter version="1.0">
+    <filter root="/apps/my_site"/>
+    <filter root="/content/my_site"/>
+</workspaceFilter>