Squash root archive folder (#88)

* Squash root archive folder

* lint bleh

* comments

Author: davidnewhall

7z.go

@@ -79,7 +79,9 @@ func extract7z(xFile *XFile) (int64, []string, []string, error) {
 		xFile.Debugf("Wrote archived file: %s (%d bytes), total: %d files and %d bytes", wfile, fSize, len(files), size)
 	}
 
-	return size, files, sevenZip.Volumes(), nil
+	files, err = xFile.cleanup(files)
+
+	return size, files, sevenZip.Volumes(), err
 }
 
 func (x *XFile) un7zip(zipFile *sevenzip.File) (int64, string, error) {

ar.go

@@ -28,14 +28,12 @@ func (x *XFile) unAr(reader io.Reader) (int64, []string, error) {
 
 	for {
 		header, err := arReader.Next()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
 
-		switch {
-		case errors.Is(err, io.EOF):
-			return size, files, nil
-		case err != nil:
 			return size, files, fmt.Errorf("%s: arReader.Next: %w", x.FilePath, err)
-		case header == nil:
-			return size, files, fmt.Errorf("%w: %s", ErrInvalidHead, x.FilePath)
 		}
 
 		file := &file{
@@ -61,4 +59,8 @@ func (x *XFile) unAr(reader io.Reader) (int64, []string, error) {
 		files = append(files, file.Path)
 		size += fSize
 	}
+
+	files, err := x.cleanup(files)
+
+	return size, files, err
 }

files.go

@@ -112,8 +112,13 @@ type XFile struct {
 	Password string
 	// (RAR/7z) Archive passwords (to try multiple).
 	Passwords []string
+	// If the archive only has one directory in the root, then setting
+	// this true will cause the extracted content to be moved into the
+	// output folder, and the root folder in the archive to be removed.
+	SquashRoot bool
 	// Logger allows printing debug messages.
-	log Logger
+	log       Logger
+	moveFiles func(fromPath, toPath string, overwrite bool) ([]string, error)
 }
 
 // Filter is the input to find compressed files.
@@ -313,6 +318,8 @@ func (x *XFile) Extract() (size int64, filesList, archiveList []string, err erro
 // Returns size of extracted data, list of extracted files, list of archives processed, and/or error.
 func ExtractFile(xFile *XFile) (size int64, filesList, archiveList []string, err error) {
 	sName := strings.ToLower(xFile.FilePath)
+	// just borrowing this... Has to go into an interface to avoid a cycle.
+	xFile.moveFiles = parseConfig(&Config{Logger: xFile.log}).MoveFiles
 
 	for _, ext := range extension2function {
 		if strings.HasSuffix(sName, ext.Extension) {
@@ -541,6 +548,38 @@ func (x *XFile) SetLogger(logger Logger) {
 	x.log = logger
 }
 
+// cleanup runs after a successful extract.
+// The intent it to move files into their final location.
+func (x *XFile) cleanup(files []string) ([]string, error) {
+	files, err := x.squashRoot(files)
+	if err != nil {
+		return files, err
+	}
+
+	return files, nil
+}
+
+func (x *XFile) squashRoot(files []string) ([]string, error) {
+	if !x.SquashRoot {
+		return files, nil
+	}
+
+	roots := map[string]bool{}
+	//nolint:mnd
+	for _, path := range files {
+		// Remove the output dir suffix, then split on `/` (or `\`) and get the first item.
+		roots[strings.SplitN(strings.TrimPrefix(path, x.OutputDir), string(filepath.Separator), 2)[0]] = true
+	}
+
+	if len(roots) == 1 { // only 1 root folder...
+		for root := range roots { // ...move it's content up a level.
+			return x.moveFiles(filepath.Join(x.OutputDir, root), x.OutputDir, false)
+		}
+	}
+
+	return files, nil
+}
+
 func (x *XFile) safeDirMode(current os.FileMode) os.FileMode {
 	if current.Perm() == 0 {
 		return x.DirMode

iso.go

@@ -69,7 +69,9 @@ func (x *XFile) uniso(isoFile *iso9660.File, parent string) (int64, []string, er
 		files = append(files, childFiles...)
 	}
 
-	return size, files, nil
+	files, err = x.cleanup(files)
+
+	return size, files, err
 }
 
 func (x *XFile) unisofile(isoFile *iso9660.File, wfile string) (int64, []string, error) {

logger.go

@@ -0,0 +1,9 @@
+package xtractr
+
+// NoLogger gives you an empty Logger for cases when you don't want any output.
+func NoLogger() Logger { return &antiLogger{} } //nolint:ireturn // It's on purpose.
+
+type antiLogger struct{}
+
+func (*antiLogger) Printf(_ string, _ ...any) {}
+func (*antiLogger) Debugf(_ string, _ ...any) {}

rar.go

@@ -81,14 +81,12 @@ func (x *XFile) unrar(rarReader *rardecode.ReadCloser) (int64, []string, error)
 
 	for {
 		header, err := rarReader.Next()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
 
-		switch {
-		case errors.Is(err, io.EOF):
-			return size, files, nil
-		case err != nil:
 			return size, files, fmt.Errorf("rarReader.Next: %w", err)
-		case header == nil:
-			return size, files, fmt.Errorf("%w: %s", ErrInvalidHead, x.FilePath)
 		}
 
 		file := &file{
@@ -127,4 +125,8 @@ func (x *XFile) unrar(rarReader *rardecode.ReadCloser) (int64, []string, error)
 		size += fSize
 		x.Debugf("Wrote archived file: %s (%d bytes), total: %d files and %d bytes", file.Path, fSize, len(files), size)
 	}
+
+	files, err := x.cleanup(files)
+
+	return size, files, err
 }

start.go

@@ -126,6 +126,10 @@ func parseConfig(config *Config) *Xtractr {
 		config.Suffix = DefaultSuffix
 	}
 
+	if config.Logger == nil {
+		config.Logger = NoLogger()
+	}
+
 	return &Xtractr{
 		config: config,
 		done:   make(chan struct{}),

tar.go

@@ -110,14 +110,12 @@ func (x *XFile) untar(reader io.Reader) (int64, []string, error) {
 
 	for {
 		header, err := tarReader.Next()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
 
-		switch {
-		case errors.Is(err, io.EOF):
-			return size, files, nil
-		case err != nil:
 			return size, files, fmt.Errorf("%s: tarReader.Next: %w", x.FilePath, err)
-		case header == nil:
-			return size, files, fmt.Errorf("%w: %s", ErrInvalidHead, x.FilePath)
 		}
 
 		fSize, err := x.untarFile(header, tarReader)
@@ -129,6 +127,10 @@ func (x *XFile) untar(reader io.Reader) (int64, []string, error) {
 		size += fSize
 		x.Debugf("Wrote archived file: %s (%d bytes), total: %d files and %d bytes", header.Name, fSize, len(files), size)
 	}
+
+	files, err := x.cleanup(files)
+
+	return size, files, err
 }
 
 func (x *XFile) untarFile(header *tar.Header, tarReader *tar.Reader) (int64, error) {

zip.go

@@ -33,7 +33,9 @@ func ExtractZIP(xFile *XFile) (size int64, filesList []string, err error) {
 		xFile.Debugf("Wrote archived file: %s (%d bytes), total: %d files and %d bytes", wfile, fSize, len(files), size)
 	}
 
-	return size, files, nil
+	files, err = xFile.cleanup(files)
+
+	return size, files, err
 }
 
 func (x *XFile) unzip(zipFile *zip.File) (int64, string, error) {