Visit all path until basePath

pathwalker.go

/*
Usage example:

func testAction(pathName, basePath string) {
	act := func(p pathwalker.PathInfo) error {
		if p.FileInfo.IsDir() {
			fmt.Printf("  Dir=%s\n", p.FullPath)
		} else {
			fmt.Printf("  File=%s\n", p.FullPath)
		}
		return nil
	}

	fmt.Printf("\n--- TEST ---\n")
	fmt.Printf("Base: %s, Path: %s\n", basePath, pathName)
	pw := pathwalker.NewPathWalker(pathName, basePath)
	n, err := pw.Walk(act)
	fmt.Printf("N=%d/%d, err=%v\n", n, len(pw.VisitedPaths()), err)
}
*/

package pathwalker

import (
	"os"
	"path/filepath"
	"strings"
)

type PathAction func(PathInfo) error
type PathInfo struct {
	FileInfo os.FileInfo
	FullPath string
}
type PathWalker struct {
	pathName     string
	basePath     string
	visitedPaths []PathInfo
	lastFi       os.FileInfo
}

//NewPathWalker creates PathWalker instance
func NewPathWalker(pathName, basePath string) *PathWalker {
	return &PathWalker{
		pathName: pathName,
		basePath: basePath,
	}
}

func (w *PathWalker) visit() (bool, error) {
	//Make sure path ends with separator
	basePath := filepath.Clean(w.basePath + string(filepath.Separator))
	baseInfo, err := os.Lstat(basePath)
	if err != nil {
		return false, err
	}

	//clean path name
	fi, err := os.Lstat(w.pathName)
	if err != nil {
		return false, err
	} else if fi.IsDir() {
		//When pathname is a directory, remove latest separator
		sep := string(filepath.Separator)
		cleanPath := filepath.Clean(w.pathName + sep)
		w.pathName = strings.TrimRight(cleanPath, sep)
	} else {
		w.pathName = filepath.Clean(w.pathName)
	}
	return w.doVisit(w.pathName, baseInfo)
}

//visit path recursively
func (w *PathWalker) doVisit(pathName string, baseInfo os.FileInfo) (bool, error) {
	//Get file info
	fi, err := os.Lstat(pathName)
	if err != nil {
		return false, err
	}

	//Stop when basePath equal to pathName
	if os.SameFile(fi, baseInfo) {
		return true, nil
	}
	
	//Top directory reached, but does not match baseInfo
	if w.lastFi != nil && os.SameFile(w.lastFi, fi) {
		return false, nil
	}
	w.lastFi = fi

	//Append to visited path list
	w.visitedPaths = append(w.visitedPaths, PathInfo{fi, pathName})

	//Move to upper path
	up := filepath.Dir(pathName)
	if up == "." {
		return false, nil
	}

	//Visit upper directory
	return w.doVisit(up, baseInfo)
}

//Walk perform action then return number of proceed paths and error
func (w *PathWalker) Walk(act PathAction) (int, error) {
	n := 0
	ok, err := w.visit()
	if err != nil {
		return 0, err
	} else if ok && act != nil {
		for _, pi := range w.visitedPaths {
			err := act(pi)
			if err != nil {
				return n, err
			}
			n++
		}
	}
	return n, nil
}

//VisitedPaths return list of visited paths
func (w *PathWalker) VisitedPaths() []PathInfo {
	return w.visitedPaths
}