status_common_prefix.go

package cmd

import "path"

/*
commonPrefix returns common most significant part of a 'path'

	'sep' path separator
	'paths' slice where commonality must be found
*/
func commonPrefix(sep byte, paths []string) string {

	/* Handle special cases */

	switch len(paths) {
	case 0:
		return ""
	case 1:
		return path.Clean(paths[0])
	}

	/* Note, we treat string as []byte, not []rune as is often
	done in Go. (And sep as byte, not rune). This is because
	most/all supported OS' treat paths as string of non-zero
	bytes. A filename may be displayed as a sequence of Unicode
	runes (typically encoded as UTF-8) but paths are
	not required to be valid UTF-8 or in any normalized form
	(e.g. "é" (U+00C9) and "é" (U+0065,U+0301) are different
	file names */
	c := []byte(path.Clean(paths[0]))

	/* We add a trailing sep to handle the case where the
	common prefix directory is included in the path list
	(e.g. /home/user1, /home/user1/foo, /home/user1/bar).
	path.Clean will have cleaned off trailing / separators with
	the exception of the root directory, "/" (in which case we
	make it "//", but this will get fixed up to "/" bellow) */
	c = append(c, sep)

	/* Ignore the first path since it's already in c */

	for _, v := range paths[1:] {

		/* Clean up each path before testing it */

		v = path.Clean(v) + string(sep)

		/* Find the first non-common byte and truncate c */

		if len(v) < len(c) {
			c = c[:len(v)]
		}
		for i := 0; i < len(c); i++ {
			if v[i] != c[i] {
				c = c[:i]
				break
			}
		}
	}

	/* Remove trailing non-separator characters and the final separator */

	for i := len(c) - 1; i >= 0; i-- {
		if c[i] == sep {
			c = c[:i]
			break
		}
	}

	return string(c)
}