mirror of
https://github.com/golang/go
synced 2024-10-04 15:11:20 -06:00
ec81b1259b
file systems provided via -path R=rsc CC=golang-dev https://golang.org/cl/2182041
209 lines
4.8 KiB
Go
209 lines
4.8 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This file implements the Mapping data structure.
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
pathutil "path"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
|
|
// A Mapping object maps relative paths (e.g. from URLs)
|
|
// to absolute paths (of the file system) and vice versa.
|
|
//
|
|
// A Mapping object consists of a list of individual mappings
|
|
// of the form: prefix -> path which are interpreted as follows:
|
|
// A relative path of the form prefix/tail is to be mapped to
|
|
// the absolute path/tail, if that absolute path exists in the file
|
|
// system. Given a Mapping object, a relative path is mapped to an
|
|
// absolute path by trying each of the individual mappings in order,
|
|
// until a valid mapping is found. For instance, for the mapping:
|
|
//
|
|
// user -> /home/user
|
|
// public -> /home/user/public
|
|
// public -> /home/build/public
|
|
//
|
|
// the relative paths below are mapped to absolute paths as follows:
|
|
//
|
|
// user/foo -> /home/user/foo
|
|
// public/net/rpc/file1.go -> /home/user/public/net/rpc/file1.go
|
|
//
|
|
// If there is no /home/user/public/net/rpc/file2.go, the next public
|
|
// mapping entry is used to map the relative path to:
|
|
//
|
|
// public/net/rpc/file2.go -> /home/build/public/net/rpc/file2.go
|
|
//
|
|
// (assuming that file exists).
|
|
//
|
|
// Each individual mapping also has a RWValue associated with it that
|
|
// may be used to store mapping-specific information. See the Iterate
|
|
// method.
|
|
//
|
|
type Mapping struct {
|
|
list []mapping
|
|
prefixes []string // lazily computed from list
|
|
}
|
|
|
|
|
|
type mapping struct {
|
|
prefix, path string
|
|
value *RWValue
|
|
}
|
|
|
|
|
|
// Init initializes the Mapping from a list of ':'-separated
|
|
// paths. Empty paths are ignored; relative paths are assumed
|
|
// to be relative to the current working directory and converted
|
|
// to absolute paths. For each path of the form:
|
|
//
|
|
// dirname/localname
|
|
//
|
|
// a mapping
|
|
//
|
|
// localname -> path
|
|
//
|
|
// is added to the Mapping object, in the order of occurrence.
|
|
// For instance, the argument:
|
|
//
|
|
// /home/user:/home/build/public
|
|
//
|
|
// leads to the following mapping:
|
|
//
|
|
// user -> /home/user
|
|
// public -> /home/build/public
|
|
//
|
|
func (m *Mapping) Init(paths string) {
|
|
pathlist := canonicalizePaths(strings.Split(paths, ":", -1), nil)
|
|
list := make([]mapping, len(pathlist))
|
|
|
|
// create mapping list
|
|
for i, path := range pathlist {
|
|
_, prefix := pathutil.Split(path)
|
|
list[i] = mapping{prefix, path, new(RWValue)}
|
|
}
|
|
|
|
m.list = list
|
|
}
|
|
|
|
|
|
// IsEmpty returns true if there are no mappings specified.
|
|
func (m *Mapping) IsEmpty() bool { return len(m.list) == 0 }
|
|
|
|
|
|
// PrefixList returns a list of all prefixes, with duplicates removed.
|
|
// For instance, for the mapping:
|
|
//
|
|
// user -> /home/user
|
|
// public -> /home/user/public
|
|
// public -> /home/build/public
|
|
//
|
|
// the prefix list is:
|
|
//
|
|
// user, public
|
|
//
|
|
func (m *Mapping) PrefixList() []string {
|
|
// compute the list lazily
|
|
if m.prefixes == nil {
|
|
list := make([]string, len(m.list))
|
|
|
|
// populate list
|
|
for i, e := range m.list {
|
|
list[i] = e.prefix
|
|
}
|
|
|
|
// sort the list and remove duplicate entries
|
|
sort.SortStrings(list)
|
|
i := 0
|
|
prev := ""
|
|
for _, path := range list {
|
|
if path != prev {
|
|
list[i] = path
|
|
i++
|
|
prev = path
|
|
}
|
|
}
|
|
|
|
m.prefixes = list[0:i]
|
|
}
|
|
|
|
return m.prefixes
|
|
}
|
|
|
|
|
|
// Fprint prints the mapping.
|
|
func (m *Mapping) Fprint(w io.Writer) {
|
|
for _, e := range m.list {
|
|
fmt.Fprintf(w, "\t%s -> %s\n", e.prefix, e.path)
|
|
}
|
|
}
|
|
|
|
|
|
func splitFirst(path string) (head, tail string) {
|
|
i := strings.Index(path, "/")
|
|
if i > 0 {
|
|
// 0 < i < len(path)
|
|
return path[0:i], path[i+1:]
|
|
}
|
|
return "", path
|
|
}
|
|
|
|
|
|
// ToAbsolute maps a relative path to an absolute path using the Mapping
|
|
// specified by the receiver. If the path cannot be mapped, the empty
|
|
// string is returned.
|
|
//
|
|
func (m *Mapping) ToAbsolute(path string) string {
|
|
prefix, tail := splitFirst(path)
|
|
for _, e := range m.list {
|
|
switch {
|
|
case e.prefix == prefix:
|
|
// use tail
|
|
case e.prefix == "":
|
|
tail = path
|
|
default:
|
|
continue // no match
|
|
}
|
|
abspath := pathutil.Join(e.path, tail)
|
|
if _, err := os.Stat(abspath); err == nil {
|
|
return abspath
|
|
}
|
|
}
|
|
|
|
return "" // no match
|
|
}
|
|
|
|
|
|
// ToRelative maps an absolute path to a relative path using the Mapping
|
|
// specified by the receiver. If the path cannot be mapped, the empty
|
|
// string is returned.
|
|
//
|
|
func (m *Mapping) ToRelative(path string) string {
|
|
for _, e := range m.list {
|
|
if strings.HasPrefix(path, e.path) {
|
|
// /absolute/prefix/foo -> prefix/foo
|
|
return pathutil.Join(e.prefix, path[len(e.path):]) // Join will remove a trailing '/'
|
|
}
|
|
}
|
|
return "" // no match
|
|
}
|
|
|
|
|
|
// Iterate calls f for each path and RWValue in the mapping (in uspecified order)
|
|
// until f returns false.
|
|
//
|
|
func (m *Mapping) Iterate(f func(path string, value *RWValue) bool) {
|
|
for _, e := range m.list {
|
|
if !f(e.path, e.value) {
|
|
return
|
|
}
|
|
}
|
|
}
|