cue/load: add package
Change-Id: Ie71f233333ad0a8294cf3cebf4f33d3e19c9200f
diff --git a/cue/load/config.go b/cue/load/config.go
new file mode 100644
index 0000000..3e1633b
--- /dev/null
+++ b/cue/load/config.go
@@ -0,0 +1,194 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "os"
+ "path/filepath"
+ "runtime"
+
+ "cuelang.org/go/cue/build"
+)
+
+const (
+ cueSuffix = ".cue"
+ defaultDir = "cue"
+ modFile = "cue.mod"
+)
+
+// FromArgsUsage is a partial usage message that applications calling
+// FromArgs may wish to include in their -help output.
+//
+// Some of the aspects of this documentation, like flags and handling '--' need
+// to be implemented by the tools.
+const FromArgsUsage = `
+<args> is a list of arguments denoting a set of instances.
+It may take one of two forms:
+
+1. A list of *.cue source files.
+
+ All of the specified files are loaded, parsed and type-checked
+ as a single instance.
+
+2. A list of relative directories to denote a package instance.
+
+ Each directory matching the pattern is loaded as a separate instance.
+ The instance contains all files in this directory and ancestor directories,
+ up to the module root, with the same package name. The package name must
+ be either uniquely determined by the files in the given directory, or
+ explicitly defined using the '-p' flag.
+
+ Files without a package clause are ignored.
+
+ Files ending in *_test.cue files are only loaded when testing.
+
+3. A list of import paths, each denoting a package.
+
+ The package's directory is loaded from the package cache. The version of the
+ package is defined in the modules cue.mod file.
+
+A '--' argument terminates the list of packages.
+`
+
+// A Config configures load behavior.
+type Config struct {
+ // Context specifies the context for the load operation.
+ // If the context is cancelled, the loader may stop early
+ // and return an ErrCancelled error.
+ // If Context is nil, the load cannot be cancelled.
+ Context *build.Context
+
+ loader *loader
+
+ modRoot string // module root for package paths ("" if unknown)
+
+ // cache specifies the package cache in which to look for packages.
+ cache string
+
+ // Package defines the name of the package to be loaded. In this is not set,
+ // the package must be uniquely defined from its context.
+ Package string
+
+ // Dir is the directory in which to run the build system's query tool
+ // that provides information about the packages.
+ // If Dir is empty, the tool is run in the current directory.
+ Dir string
+
+ // The build and release tags specify build constraints that should be
+ // considered satisfied when processing +build lines. Clients creating a new
+ // context may customize BuildTags, which defaults to empty, but it is
+ // usually an error to customize ReleaseTags, which defaults to the list of
+ // CUE releases the current release is compatible with.
+ BuildTags []string
+ releaseTags []string
+
+ // If Tests is set, the loader includes not just the packages
+ // matching a particular pattern but also any related test packages.
+ Tests bool
+
+ // If Tools is set, the loader includes tool files associated with
+ // a package.
+ Tools bool
+
+ // If DataFiles is set, the loader includes entries for directories that
+ // have no CUE files, but have recognized data files that could be converted
+ // to CUE.
+ DataFiles bool
+
+ fileSystem
+}
+
+func (c Config) newInstance(path string) *build.Instance {
+ i := c.Context.NewInstance(path, nil)
+ i.DisplayPath = path
+ return i
+}
+
+func (c Config) newErrInstance(m *match, path string, err error) *build.Instance {
+ i := c.Context.NewInstance(path, nil)
+ i.DisplayPath = path
+ i.ReportError(err)
+ return i
+}
+
+func (c Config) complete() (cfg *Config, err error) {
+ // Each major CUE release should add a tag here.
+ // Old tags should not be removed. That is, the cue1.x tag is present
+ // in all releases >= CUE 1.x. Code that requires CUE 1.x or later should
+ // say "+build cue1.x", and code that should only be built before CUE 1.x
+ // (perhaps it is the stub to use in that case) should say "+build !cue1.x".
+ c.releaseTags = []string{"cue0.1"}
+
+ if c.Dir == "" {
+ c.Dir, err = os.Getwd()
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ c.loader = &loader{cfg: &c}
+
+ if c.Context == nil {
+ c.Context = build.NewContext(build.Loader(c.loader.loadFunc(c.Dir)))
+ }
+
+ if c.cache == "" {
+ c.cache = filepath.Join(home(), defaultDir)
+ // os.MkdirAll(c.Cache, 0755) // TODO: tools task
+ }
+
+ // TODO: determine root on a package basis. Maybe we even need a
+ // pkgname.cue.mod
+ // Look to see if there is a cue.mod.
+ if c.modRoot == "" {
+ abs, err := findRoot(c.Dir)
+ if err != nil {
+ // Not using modules: only consider the current directory.
+ c.modRoot = c.Dir
+ } else {
+ c.modRoot = abs
+ }
+ }
+ return &c, nil
+}
+
+func findRoot(dir string) (string, error) {
+ abs, err := filepath.Abs(dir)
+ if err != nil {
+ return "", err
+ }
+ for {
+ info, err := os.Stat(filepath.Join(abs, modFile))
+ if err == nil && !info.IsDir() {
+ break
+ }
+ d := filepath.Dir(abs)
+ if len(d) >= len(abs) {
+ return "", err // reached top of file system, no cue.mod
+ }
+ abs = d
+ }
+ return abs, nil
+}
+
+func home() string {
+ env := "HOME"
+ if runtime.GOOS == "windows" {
+ env = "USERPROFILE"
+ } else if runtime.GOOS == "plan9" {
+ env = "home"
+ }
+ return os.Getenv(env)
+}
diff --git a/cue/load/doc.go b/cue/load/doc.go
new file mode 100644
index 0000000..d1b599f
--- /dev/null
+++ b/cue/load/doc.go
@@ -0,0 +1,16 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package load loads CUE instances.
+package load // import "cuelang.org/go/cue/load"
diff --git a/cue/load/errors.go b/cue/load/errors.go
new file mode 100644
index 0000000..6f77495
--- /dev/null
+++ b/cue/load/errors.go
@@ -0,0 +1,150 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "fmt"
+ "path/filepath"
+ "strings"
+
+ build "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/token"
+)
+
+func lastError(p *build.Instance) *packageError {
+ if p == nil {
+ return nil
+ }
+ switch v := p.Err.(type) {
+ case *packageError:
+ return v
+ }
+ return nil
+}
+
+func report(p *build.Instance, err *packageError) {
+ if err != nil {
+ p.ReportError(err)
+ }
+}
+
+// shortPath returns an absolute or relative name for path, whatever is shorter.
+func shortPath(cwd, path string) string {
+ if cwd == "" {
+ return path
+ }
+ if rel, err := filepath.Rel(cwd, path); err == nil && len(rel) < len(path) {
+ return rel
+ }
+ return path
+}
+
+// A packageError describes an error loading information about a package.
+type packageError struct {
+ ImportStack []string // shortest path from package named on command line to this one
+ Pos string // position of error
+ Err string // the error itself
+ IsImportCycle bool `json:"-"` // the error is an import cycle
+ Hard bool `json:"-"` // whether the error is soft or hard; soft errors are ignored in some places
+}
+
+func (l *loader) errPkgf(importPos []token.Position, format string, args ...interface{}) *packageError {
+ err := &packageError{
+ ImportStack: l.stk.Copy(),
+ Err: fmt.Sprintf(format, args...),
+ }
+ err.fillPos(l.cfg.Dir, importPos)
+ return err
+}
+
+func (p *packageError) fillPos(cwd string, positions []token.Position) {
+ if len(positions) > 0 && p.Pos == "" {
+ pos := positions[0]
+ pos.Filename = shortPath(cwd, pos.Filename)
+ p.Pos = pos.String()
+ }
+}
+
+func (p *packageError) Error() string {
+ // Import cycles deserve special treatment.
+ if p.IsImportCycle {
+ return fmt.Sprintf("%s\npackage %s\n", p.Err, strings.Join(p.ImportStack, "\n\timports "))
+ }
+ if p.Pos != "" {
+ // Omit import stack. The full path to the file where the error
+ // is the most important thing.
+ return p.Pos + ": " + p.Err
+ }
+ if len(p.ImportStack) == 0 {
+ return p.Err
+ }
+ return "package " + strings.Join(p.ImportStack, "\n\timports ") + ": " + p.Err
+}
+
+// noCUEError is the error used by Import to describe a directory
+// containing no buildable Go source files. (It may still contain
+// test files, files hidden by build tags, and so on.)
+type noCUEError struct {
+ Package *build.Instance
+
+ Dir string
+ Ignored bool // whether any Go files were ignored due to build tags
+}
+
+// func (e *noCUEError) Error() string {
+// msg := "no buildable CUE config files in " + e.Dir
+// if e.Ignored {
+// msg += " (.cue files ignored due to build tags)"
+// }
+// return msg
+// }
+
+func (e *noCUEError) Error() string {
+ // Count files beginning with _ and ., which we will pretend don't exist at all.
+ dummy := 0
+ for _, name := range e.Package.IgnoredCUEFiles {
+ if strings.HasPrefix(name, "_") || strings.HasPrefix(name, ".") {
+ dummy++
+ }
+ }
+
+ // path := shortPath(e.Package.Root, e.Package.Dir)
+ path := e.Package.DisplayPath
+
+ if len(e.Package.IgnoredCUEFiles) > dummy {
+ // CUE files exist, but they were ignored due to build constraints.
+ return "build constraints exclude all CUE files in " + path
+ }
+ // if len(e.Package.TestCUEFiles) > 0 {
+ // // Test CUE files exist, but we're not interested in them.
+ // // The double-negative is unfortunate but we want e.Package.Dir
+ // // to appear at the end of error message.
+ // return "no non-test CUE files in " + e.Package.Dir
+ // }
+ return "no CUE files in " + path
+}
+
+// multiplePackageError describes a directory containing
+// multiple buildable Go source files for multiple packages.
+type multiplePackageError struct {
+ Dir string // directory containing files
+ Packages []string // package names found
+ Files []string // corresponding files: Files[i] declares package Packages[i]
+}
+
+func (e *multiplePackageError) Error() string {
+ // Error string limited to two entries for compatibility.
+ return fmt.Sprintf("found packages %s (%s) and %s (%s) in %s", e.Packages[0], e.Files[0], e.Packages[1], e.Files[1], e.Dir)
+}
diff --git a/cue/load/fs.go b/cue/load/fs.go
new file mode 100644
index 0000000..0898e5f
--- /dev/null
+++ b/cue/load/fs.go
@@ -0,0 +1,173 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "io"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+// TODO: remove this file if we know we don't need it.
+
+// A fileSystem specifies the supporting context for a build.
+type fileSystem struct {
+ // By default, Import uses the operating system's file system calls
+ // to read directories and files. To read from other sources,
+ // callers can set the following functions. They all have default
+ // behaviors that use the local file system, so clients need only set
+ // the functions whose behaviors they wish to change.
+
+ // JoinPath joins the sequence of path fragments into a single path.
+ // If JoinPath is nil, Import uses filepath.Join.
+ JoinPath func(elem ...string) string
+
+ // SplitPathList splits the path list into a slice of individual paths.
+ // If SplitPathList is nil, Import uses filepath.SplitList.
+ SplitPathList func(list string) []string
+
+ // IsAbsPath reports whether path is an absolute path.
+ // If IsAbsPath is nil, Import uses filepath.IsAbs.
+ IsAbsPath func(path string) bool
+
+ // IsDir reports whether the path names a directory.
+ // If IsDir is nil, Import calls os.Stat and uses the result's IsDir method.
+ IsDir func(path string) bool
+
+ // HasSubdir reports whether dir is a subdirectory of
+ // (perhaps multiple levels below) root.
+ // If so, HasSubdir sets rel to a slash-separated path that
+ // can be joined to root to produce a path equivalent to dir.
+ // If HasSubdir is nil, Import uses an implementation built on
+ // filepath.EvalSymlinks.
+ HasSubdir func(root, dir string) (rel string, ok bool)
+
+ // ReadDir returns a slice of os.FileInfo, sorted by Name,
+ // describing the content of the named directory.
+ // If ReadDir is nil, Import uses ioutil.ReadDir.
+ ReadDir func(dir string) ([]os.FileInfo, error)
+
+ // OpenFile opens a file (not a directory) for reading.
+ // If OpenFile is nil, Import uses os.Open.
+ OpenFile func(path string) (io.ReadCloser, error)
+}
+
+// JoinPath calls ctxt.JoinPath (if not nil) or else filepath.Join.
+func (ctxt *fileSystem) joinPath(elem ...string) string {
+ if f := ctxt.JoinPath; f != nil {
+ return f(elem...)
+ }
+ return filepath.Join(elem...)
+}
+
+// splitPathList calls ctxt.SplitPathList (if not nil) or else filepath.SplitList.
+func (ctxt *fileSystem) splitPathList(s string) []string {
+ if f := ctxt.SplitPathList; f != nil {
+ return f(s)
+ }
+ return filepath.SplitList(s)
+}
+
+// isAbsPath calls ctxt.IsAbsPath (if not nil) or else filepath.IsAbs.
+func (ctxt *fileSystem) isAbsPath(path string) bool {
+ if f := ctxt.IsAbsPath; f != nil {
+ return f(path)
+ }
+ return filepath.IsAbs(path)
+}
+
+// isDir calls ctxt.IsDir (if not nil) or else uses os.Stat.
+func (ctxt *fileSystem) isDir(path string) bool {
+ if f := ctxt.IsDir; f != nil {
+ return f(path)
+ }
+ fi, err := os.Stat(path)
+ return err == nil && fi.IsDir()
+}
+
+// hasSubdir calls ctxt.HasSubdir (if not nil) or else uses
+// the local file system to answer the question.
+func (ctxt *fileSystem) hasSubdir(root, dir string) (rel string, ok bool) {
+ if f := ctxt.HasSubdir; f != nil {
+ return f(root, dir)
+ }
+
+ // Try using paths we received.
+ if rel, ok = hasSubdir(root, dir); ok {
+ return
+ }
+
+ // Try expanding symlinks and comparing
+ // expanded against unexpanded and
+ // expanded against expanded.
+ rootSym, _ := filepath.EvalSymlinks(root)
+ dirSym, _ := filepath.EvalSymlinks(dir)
+
+ if rel, ok = hasSubdir(rootSym, dir); ok {
+ return
+ }
+ if rel, ok = hasSubdir(root, dirSym); ok {
+ return
+ }
+ return hasSubdir(rootSym, dirSym)
+}
+
+func hasSubdir(root, dir string) (rel string, ok bool) {
+ const sep = string(filepath.Separator)
+ root = filepath.Clean(root)
+ if !strings.HasSuffix(root, sep) {
+ root += sep
+ }
+ dir = filepath.Clean(dir)
+ if !strings.HasPrefix(dir, root) {
+ return "", false
+ }
+ return filepath.ToSlash(dir[len(root):]), true
+}
+
+// ReadDir calls ctxt.ReadDir (if not nil) or else ioutil.ReadDir.
+func (ctxt *fileSystem) readDir(path string) ([]os.FileInfo, error) {
+ if f := ctxt.ReadDir; f != nil {
+ return f(path)
+ }
+ return ioutil.ReadDir(path)
+}
+
+// openFile calls ctxt.OpenFile (if not nil) or else os.Open.
+func (ctxt *fileSystem) openFile(path string) (io.ReadCloser, error) {
+ if fn := ctxt.OpenFile; fn != nil {
+ return fn(path)
+ }
+
+ f, err := os.Open(path)
+ if err != nil {
+ return nil, err // nil interface
+ }
+ return f, nil
+}
+
+// isFile determines whether path is a file by trying to open it.
+// It reuses openFile instead of adding another function to the
+// list in Context.
+func (ctxt *fileSystem) isFile(path string) bool {
+ f, err := ctxt.openFile(path)
+ if err != nil {
+ return false
+ }
+ f.Close()
+ return true
+}
diff --git a/cue/load/import.go b/cue/load/import.go
new file mode 100644
index 0000000..79813a5
--- /dev/null
+++ b/cue/load/import.go
@@ -0,0 +1,570 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+ pathpkg "path"
+ "path/filepath"
+ "sort"
+ "strconv"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+
+ "cuelang.org/go/cue/ast"
+ build "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/encoding"
+ "cuelang.org/go/cue/parser"
+ "cuelang.org/go/cue/token"
+)
+
+// An importMode controls the behavior of the Import method.
+type importMode uint
+
+const (
+ // If findOnly is set, Import stops after locating the directory
+ // that should contain the sources for a package. It does not
+ // read any files in the directory.
+ findOnly importMode = 1 << iota
+
+ // If importComment is set, parse import comments on package statements.
+ // Import returns an error if it finds a comment it cannot understand
+ // or finds conflicting comments in multiple source files.
+ // See golang.org/s/go14customimport for more information.
+ importComment
+
+ allowAnonymous
+)
+
+// importPkg returns details about the CUE package named by the import path,
+// interpreting local import paths relative to the srcDir directory.
+// If the path is a local import path naming a package that can be imported
+// using a standard import path, the returned package will set p.ImportPath
+// to that path.
+//
+// In the directory and ancestor directories up to including one with a
+// cue.mod file, all .cue files are considered part of the package except for:
+//
+// - files starting with _ or . (likely editor temporary files)
+// - files with build constraints not satisfied by the context
+//
+// If an error occurs, importPkg sets the error in the returned instance,
+// which then may contain partial information.
+//
+func (l *loader) importPkg(path, srcDir string) *build.Instance {
+ l.stk.Push(path)
+ defer l.stk.Pop()
+
+ cfg := l.cfg
+ ctxt := &cfg.fileSystem
+
+ parentPath := path
+ if isLocalImport(path) {
+ parentPath = filepath.Join(srcDir, path)
+ }
+ p := cfg.Context.NewInstance(path, l.loadFunc(parentPath))
+ p.DisplayPath = path
+
+ isLocal := isLocalImport(path)
+ var modDir string
+ // var modErr error
+ if !isLocal {
+ // TODO(mpvl): support module lookup
+ }
+
+ p.Local = isLocal
+
+ if err := updateDirs(cfg, p, path, srcDir, 0); err != nil {
+ p.ReportError(err)
+ return p
+ }
+
+ if modDir == "" && path != cleanImport(path) {
+ report(p, l.errPkgf(nil,
+ "non-canonical import path: %q should be %q", path, pathpkg.Clean(path)))
+ p.Incomplete = true
+ return p
+ }
+
+ fp := newFileProcessor(cfg, p)
+
+ root := p.Dir
+
+ for dir := p.Dir; ctxt.isDir(dir); {
+ files, err := ctxt.readDir(dir)
+ if err != nil {
+ p.ReportError(err)
+ return p
+ }
+ rootFound := false
+ for _, f := range files {
+ if f.IsDir() {
+ continue
+ }
+ if fp.add(dir, f.Name(), importComment) {
+ root = dir
+ }
+ if f.Name() == "cue.mod" {
+ root = dir
+ rootFound = true
+ }
+ }
+
+ if rootFound || dir == p.Root || fp.pkg.PkgName == "" {
+ break
+ }
+
+ // From now on we just ignore files that do not belong to the same
+ // package.
+ fp.ignoreOther = true
+
+ parent, _ := filepath.Split(filepath.Clean(dir))
+ if parent == dir {
+ break
+ }
+ dir = parent
+ }
+
+ rewriteFiles(p, root, false)
+ if err := fp.finalize(); err != nil {
+ p.ReportError(err)
+ return p
+ }
+
+ for _, f := range p.CUEFiles {
+ if !filepath.IsAbs(f) {
+ f = filepath.Join(root, f)
+ }
+ p.AddFile(f, nil)
+ }
+ p.Complete()
+ return p
+}
+
+// loadFunc creates a LoadFunc that can be used to create new build.Instances.
+func (l *loader) loadFunc(parentPath string) build.LoadFunc {
+
+ return func(path string) *build.Instance {
+ cfg := l.cfg
+
+ // TODO: HACK: for now we don't handle any imports that are not
+ // relative paths.
+ if !isLocalImport(path) {
+ return nil
+ }
+
+ if strings.Contains(path, "@") {
+ i := cfg.newInstance(path)
+ report(i, l.errPkgf(nil,
+ "can only use path@version syntax with 'cue get'"))
+ return i
+ }
+
+ return l.importPkg(path, parentPath)
+ }
+}
+
+func updateDirs(c *Config, p *build.Instance, path, srcDir string, mode importMode) error {
+ ctxt := &c.fileSystem
+ // path := p.ImportPath
+ if path == "" {
+ return fmt.Errorf("import %q: invalid import path", path)
+ }
+
+ if isLocalImport(path) {
+ if srcDir == "" {
+ return fmt.Errorf("import %q: import relative to unknown directory", path)
+ }
+ if !ctxt.isAbsPath(path) {
+ p.Dir = ctxt.joinPath(srcDir, path)
+ }
+ return nil
+ }
+
+ if strings.HasPrefix(path, "/") {
+ return fmt.Errorf("import %q: cannot import absolute path", path)
+ }
+
+ // TODO: Lookup the import in dir "pkg" at the module root.
+
+ // package was not found
+ return fmt.Errorf("cannot find package %q", path)
+}
+
+func normPrefix(root, path string, isLocal bool) string {
+ root = filepath.Clean(root)
+ prefix := ""
+ if isLocal {
+ prefix = "." + string(filepath.Separator)
+ }
+ if !strings.HasSuffix(root, string(filepath.Separator)) &&
+ strings.HasPrefix(path, root) {
+ path = prefix + path[len(root)+1:]
+ }
+ return path
+}
+
+func rewriteFiles(p *build.Instance, root string, isLocal bool) {
+ p.Root = root
+ for i, path := range p.CUEFiles {
+ p.CUEFiles[i] = normPrefix(root, path, isLocal)
+ sortParentsFirst(p.CUEFiles)
+ }
+ for i, path := range p.TestCUEFiles {
+ p.TestCUEFiles[i] = normPrefix(root, path, isLocal)
+ sortParentsFirst(p.TestCUEFiles)
+ }
+ for i, path := range p.ToolCUEFiles {
+ p.ToolCUEFiles[i] = normPrefix(root, path, isLocal)
+ sortParentsFirst(p.ToolCUEFiles)
+ }
+ for i, path := range p.IgnoredCUEFiles {
+ if strings.HasPrefix(path, root) {
+ p.IgnoredCUEFiles[i] = normPrefix(root, path, isLocal)
+ }
+ }
+ for i, path := range p.InvalidCUEFiles {
+ p.InvalidCUEFiles[i] = normPrefix(root, path, isLocal)
+ sortParentsFirst(p.InvalidCUEFiles)
+ }
+}
+
+func sortParentsFirst(s []string) {
+ sort.Slice(s, func(i, j int) bool {
+ return len(filepath.Dir(s[i])) < len(filepath.Dir(s[j]))
+ })
+}
+
+type fileProcessor struct {
+ firstFile string
+ firstCommentFile string
+ imported map[string][]token.Position
+ allTags map[string]bool
+ allFiles bool
+ ignoreOther bool // ignore files from other packages
+
+ c *Config
+ pkg *build.Instance
+
+ err error
+}
+
+func newFileProcessor(c *Config, p *build.Instance) *fileProcessor {
+ return &fileProcessor{
+ imported: make(map[string][]token.Position),
+ allTags: make(map[string]bool),
+ c: c,
+ pkg: p,
+ }
+}
+
+func (fp *fileProcessor) finalize() error {
+ p := fp.pkg
+ if fp.err != nil {
+ return fp.err
+ }
+ if len(p.CUEFiles) == 0 && !fp.c.DataFiles {
+ return &noCUEError{Package: p, Dir: p.Dir, Ignored: len(p.IgnoredCUEFiles) > 0}
+ }
+
+ for tag := range fp.allTags {
+ p.AllTags = append(p.AllTags, tag)
+ }
+ sort.Strings(p.AllTags)
+
+ p.ImportPaths, _ = cleanImports(fp.imported)
+
+ return nil
+}
+
+func (fp *fileProcessor) add(root, path string, mode importMode) (added bool) {
+ fullPath := path
+ if !filepath.IsAbs(path) {
+ fullPath = filepath.Join(root, path)
+ }
+ name := filepath.Base(fullPath)
+ dir := filepath.Dir(fullPath)
+
+ fset := token.NewFileSet()
+ ext := nameExt(name)
+ p := fp.pkg
+
+ badFile := func(err error) bool {
+ if fp.err == nil {
+ fp.err = err
+ }
+ p.InvalidCUEFiles = append(p.InvalidCUEFiles, fullPath)
+ return true
+ }
+
+ match, data, filename, err := matchFile(fp.c, dir, name, true, fp.allFiles, fp.allTags)
+ if err != nil {
+ return badFile(err)
+ }
+ if !match {
+ if ext == cueSuffix {
+ p.IgnoredCUEFiles = append(p.IgnoredCUEFiles, fullPath)
+ } else if encoding.MapExtension(ext) != nil {
+ p.DataFiles = append(p.DataFiles, fullPath)
+ }
+ return false // don't mark as added
+ }
+
+ pf, err := parser.ParseFile(fset, filename, data, parser.ImportsOnly, parser.ParseComments)
+ if err != nil {
+ return badFile(err)
+ }
+
+ pkg := ""
+ if pf.Name != nil {
+ pkg = pf.Name.Name
+ }
+ if pkg == "" && mode&allowAnonymous == 0 {
+ p.IgnoredCUEFiles = append(p.IgnoredCUEFiles, fullPath)
+ return false // don't mark as added
+ }
+
+ if fp.c.Package != "" {
+ if pkg != fp.c.Package {
+ if fp.ignoreOther {
+ p.IgnoredCUEFiles = append(p.IgnoredCUEFiles, fullPath)
+ return false
+ }
+ // TODO: package does not conform with requested.
+ return badFile(fmt.Errorf("%s: found package %q; want %q", filename, pkg, fp.c.Package))
+ }
+ } else if fp.firstFile == "" {
+ p.PkgName = pkg
+ fp.firstFile = name
+ } else if pkg != p.PkgName {
+ if fp.ignoreOther {
+ p.IgnoredCUEFiles = append(p.IgnoredCUEFiles, fullPath)
+ return false
+ }
+ return badFile(&multiplePackageError{
+ Dir: p.Dir,
+ Packages: []string{p.PkgName, pkg},
+ Files: []string{fp.firstFile, name},
+ })
+ }
+
+ isTest := strings.HasSuffix(name, "_test"+cueSuffix)
+ isTool := strings.HasSuffix(name, "_tool"+cueSuffix)
+
+ if mode&importComment != 0 {
+ qcom, line := findimportComment(data)
+ if line != 0 {
+ com, err := strconv.Unquote(qcom)
+ if err != nil {
+ badFile(fmt.Errorf("%s:%d: cannot parse import comment", filename, line))
+ } else if p.ImportComment == "" {
+ p.ImportComment = com
+ fp.firstCommentFile = name
+ } else if p.ImportComment != com {
+ badFile(fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, fp.firstCommentFile, com, name, p.Dir))
+ }
+ }
+ }
+
+ for _, decl := range pf.Decls {
+ d, ok := decl.(*ast.ImportDecl)
+ if !ok {
+ continue
+ }
+ for _, spec := range d.Specs {
+ quoted := spec.Path.Value
+ path, err := strconv.Unquote(quoted)
+ if err != nil {
+ log.Panicf("%s: parser returned invalid quoted string: <%s>", filename, quoted)
+ }
+ if !isTest || fp.c.Tests {
+ fp.imported[path] = append(fp.imported[path], fset.Position(spec.Pos()))
+ }
+ }
+ }
+ switch {
+ case isTest:
+ p.TestCUEFiles = append(p.TestCUEFiles, fullPath)
+ case isTool:
+ p.ToolCUEFiles = append(p.TestCUEFiles, fullPath)
+ default:
+ p.CUEFiles = append(p.CUEFiles, fullPath)
+ }
+ return true
+}
+
+func nameExt(name string) string {
+ i := strings.LastIndex(name, ".")
+ if i < 0 {
+ return ""
+ }
+ return name[i:]
+}
+
+// hasCUEFiles reports whether dir contains any files with names ending in .go.
+// For a vendor check we must exclude directories that contain no .go files.
+// Otherwise it is not possible to vendor just a/b/c and still import the
+// non-vendored a/b. See golang.org/issue/13832.
+func hasCUEFiles(ctxt *fileSystem, dir string) bool {
+ ents, _ := ctxt.readDir(dir)
+ for _, ent := range ents {
+ if !ent.IsDir() && strings.HasSuffix(ent.Name(), cueSuffix) {
+ return true
+ }
+ }
+ return false
+}
+
+func findimportComment(data []byte) (s string, line int) {
+ // expect keyword package
+ word, data := parseWord(data)
+ if string(word) != "package" {
+ return "", 0
+ }
+
+ // expect package name
+ _, data = parseWord(data)
+
+ // now ready for import comment, a // or /* */ comment
+ // beginning and ending on the current line.
+ for len(data) > 0 && (data[0] == ' ' || data[0] == '\t' || data[0] == '\r') {
+ data = data[1:]
+ }
+
+ var comment []byte
+ switch {
+ case bytes.HasPrefix(data, slashSlash):
+ i := bytes.Index(data, newline)
+ if i < 0 {
+ i = len(data)
+ }
+ comment = data[2:i]
+ case bytes.HasPrefix(data, slashStar):
+ data = data[2:]
+ i := bytes.Index(data, starSlash)
+ if i < 0 {
+ // malformed comment
+ return "", 0
+ }
+ comment = data[:i]
+ if bytes.Contains(comment, newline) {
+ return "", 0
+ }
+ }
+ comment = bytes.TrimSpace(comment)
+
+ // split comment into `import`, `"pkg"`
+ word, arg := parseWord(comment)
+ if string(word) != "import" {
+ return "", 0
+ }
+
+ line = 1 + bytes.Count(data[:cap(data)-cap(arg)], newline)
+ return strings.TrimSpace(string(arg)), line
+}
+
+var (
+ slashSlash = []byte("//")
+ slashStar = []byte("/*")
+ starSlash = []byte("*/")
+ newline = []byte("\n")
+)
+
+// skipSpaceOrComment returns data with any leading spaces or comments removed.
+func skipSpaceOrComment(data []byte) []byte {
+ for len(data) > 0 {
+ switch data[0] {
+ case ' ', '\t', '\r', '\n':
+ data = data[1:]
+ continue
+ case '/':
+ if bytes.HasPrefix(data, slashSlash) {
+ i := bytes.Index(data, newline)
+ if i < 0 {
+ return nil
+ }
+ data = data[i+1:]
+ continue
+ }
+ if bytes.HasPrefix(data, slashStar) {
+ data = data[2:]
+ i := bytes.Index(data, starSlash)
+ if i < 0 {
+ return nil
+ }
+ data = data[i+2:]
+ continue
+ }
+ }
+ break
+ }
+ return data
+}
+
+// parseWord skips any leading spaces or comments in data
+// and then parses the beginning of data as an identifier or keyword,
+// returning that word and what remains after the word.
+func parseWord(data []byte) (word, rest []byte) {
+ data = skipSpaceOrComment(data)
+
+ // Parse past leading word characters.
+ rest = data
+ for {
+ r, size := utf8.DecodeRune(rest)
+ if unicode.IsLetter(r) || '0' <= r && r <= '9' || r == '_' {
+ rest = rest[size:]
+ continue
+ }
+ break
+ }
+
+ word = data[:len(data)-len(rest)]
+ if len(word) == 0 {
+ return nil, nil
+ }
+
+ return word, rest
+}
+
+func cleanImports(m map[string][]token.Position) ([]string, map[string][]token.Position) {
+ all := make([]string, 0, len(m))
+ for path := range m {
+ all = append(all, path)
+ }
+ sort.Strings(all)
+ return all, m
+}
+
+// // Import is shorthand for Default.Import.
+// func Import(path, srcDir string, mode ImportMode) (*Package, error) {
+// return Default.Import(path, srcDir, mode)
+// }
+
+// // ImportDir is shorthand for Default.ImportDir.
+// func ImportDir(dir string, mode ImportMode) (*Package, error) {
+// return Default.ImportDir(dir, mode)
+// }
+
+var slashslash = []byte("//")
+
+// isLocalImport reports whether the import path is
+// a local import path, like ".", "..", "./foo", or "../foo".
+func isLocalImport(path string) bool {
+ return path == "." || path == ".." ||
+ strings.HasPrefix(path, "./") || strings.HasPrefix(path, "../")
+}
diff --git a/cue/load/import_test.go b/cue/load/import_test.go
new file mode 100644
index 0000000..341999b
--- /dev/null
+++ b/cue/load/import_test.go
@@ -0,0 +1,121 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "os"
+ "path/filepath"
+ "reflect"
+ "testing"
+
+ build "cuelang.org/go/cue/build"
+)
+
+const testdata = "./testdata/"
+
+func getInst(pkg, cwd string) (*build.Instance, error) {
+ c, _ := (&Config{}).complete()
+ l := loader{cfg: c}
+ p := l.importPkg(pkg, cwd)
+ return p, p.Err
+}
+
+func TestDotSlashImport(t *testing.T) {
+ c, _ := (&Config{}).complete()
+ l := loader{cfg: c}
+ p := l.importPkg(".", testdata+"other")
+ err := p.Err
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(p.ImportPaths) != 1 || p.ImportPaths[0] != "./file" {
+ t.Fatalf("testdata/other: Imports=%v, want [./file]", p.ImportPaths)
+ }
+
+ p1, err := getInst("./file", testdata+"other")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if p1.PkgName != "file" {
+ t.Fatalf("./file: Name=%q, want %q", p1.PkgName, "file")
+ }
+ dir := filepath.Clean(testdata + "other/file") // Clean to use \ on Windows
+ if p1.Dir != dir {
+ t.Fatalf("./file: Dir=%q, want %q", p1.PkgName, dir)
+ }
+}
+
+func TestEmptyImport(t *testing.T) {
+ p, err := getInst("", "")
+ if err == nil {
+ t.Fatal(`Import("") returned nil error.`)
+ }
+ if p == nil {
+ t.Fatal(`Import("") returned nil package.`)
+ }
+ if p.DisplayPath != "" {
+ t.Fatalf("DisplayPath=%q, want %q.", p.DisplayPath, "")
+ }
+}
+
+func TestEmptyFolderImport(t *testing.T) {
+ _, err := getInst(".", testdata+"empty")
+ if _, ok := err.(*noCUEError); !ok {
+ t.Fatal(`Import("testdata/empty") did not return NoCUEError.`)
+ }
+}
+
+func TestIgnoredCUEFilesImport(t *testing.T) {
+ _, err := getInst(".", testdata+"ignored")
+ e, ok := err.(*noCUEError)
+ if !ok {
+ t.Fatal(`Import("testdata/ignored") did not return NoCUEError.`)
+ }
+ if !e.Ignored {
+ t.Fatal(`Import("testdata/ignored") should have ignored CUE files.`)
+ }
+}
+
+func TestMultiplePackageImport(t *testing.T) {
+ _, err := getInst(".", testdata+"multi")
+ mpe, ok := err.(*multiplePackageError)
+ if !ok {
+ t.Fatal(`Import("testdata/multi") did not return MultiplePackageError.`)
+ }
+ want := &multiplePackageError{
+ Dir: filepath.FromSlash("testdata/multi"),
+ Packages: []string{"main", "test_package"},
+ Files: []string{"file.cue", "file_appengine.cue"},
+ }
+ if !reflect.DeepEqual(mpe, want) {
+ t.Errorf("got %#v; want %#v", mpe, want)
+ }
+}
+
+func TestLocalDirectory(t *testing.T) {
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ p, err := getInst(".", cwd)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if p.DisplayPath != "." {
+ t.Fatalf("DisplayPath=%q, want %q", p.DisplayPath, ".")
+ }
+}
diff --git a/cue/load/loader.go b/cue/load/loader.go
new file mode 100644
index 0000000..670bf30
--- /dev/null
+++ b/cue/load/loader.go
@@ -0,0 +1,261 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+// Files in package are to a large extent based on Go files from the following
+// Go packages:
+// - cmd/go/internal/load
+// - go/build
+
+import (
+ "errors"
+ "fmt"
+ "os"
+ pathpkg "path"
+ "path/filepath"
+ "strings"
+ "unicode"
+
+ build "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/token"
+)
+
+// Instances returns the instances named by the command line arguments 'args'.
+// If errors occur trying to load an instance it is returned with Incomplete
+// set. Errors directly related to loading the instance are recorded in this
+// instance, but errors that occur loading dependencies are recorded in these
+// dependencies.
+func Instances(args []string, c *Config) []*build.Instance {
+ if c == nil {
+ c = &Config{}
+ }
+
+ c, err := c.complete()
+ if err != nil {
+ return nil
+ }
+
+ l := c.loader
+
+ if len(args) > 0 && strings.HasSuffix(args[0], cueSuffix) {
+ return []*build.Instance{l.cueFilesPackage(args)}
+ }
+
+ dummy := c.newInstance("user")
+ dummy.Local = true
+
+ a := []*build.Instance{}
+ for _, m := range l.importPaths(args) {
+ if m.Err != nil {
+ inst := c.newErrInstance(m, "", m.Err)
+ a = append(a, inst)
+ continue
+ }
+ a = append(a, m.Pkgs...)
+ }
+ return a
+}
+
+// Mode flags for loadImport and download (in get.go).
+const (
+ // resolveImport means that loadImport should do import path expansion.
+ // That is, resolveImport means that the import path came from
+ // a source file and has not been expanded yet to account for
+ // vendoring or possible module adjustment.
+ // Every import path should be loaded initially with resolveImport,
+ // and then the expanded version (for example with the /vendor/ in it)
+ // gets recorded as the canonical import path. At that point, future loads
+ // of that package must not pass resolveImport, because
+ // disallowVendor will reject direct use of paths containing /vendor/.
+ resolveImport = 1 << iota
+
+ // resolveModule is for download (part of "go get") and indicates
+ // that the module adjustment should be done, but not vendor adjustment.
+ resolveModule
+
+ // getTestDeps is for download (part of "go get") and indicates
+ // that test dependencies should be fetched too.
+ getTestDeps
+)
+
+func firstPos(p []token.Position) token.Position {
+ if len(p) == 0 {
+ return token.Position{}
+ }
+ return p[0]
+}
+
+type loader struct {
+ cfg *Config
+ stk importStack
+}
+
+func (l *loader) abs(filename string) string {
+ if !isLocalImport(filename) {
+ return filename
+ }
+ return filepath.Join(l.cfg.Dir, filename)
+}
+
+// cueFilesPackage creates a package for building a collection of CUE files
+// (typically named on the command line).
+func (l *loader) cueFilesPackage(files []string) *build.Instance {
+ cfg := l.cfg
+ // ModInit() // TODO: support modules
+ for _, f := range files {
+ if !strings.HasSuffix(f, ".cue") {
+ return cfg.newErrInstance(nil, f,
+ errors.New("named files must be .cue files"))
+ }
+ }
+
+ pkg := l.cfg.Context.NewInstance(cfg.Dir, l.loadFunc(cfg.Dir))
+ // TODO: add fiels directly?
+ fp := newFileProcessor(cfg, pkg)
+ for _, file := range files {
+ path := file
+ if !filepath.IsAbs(file) {
+ path = filepath.Join(cfg.Dir, file)
+ }
+ fi, err := os.Stat(path)
+ if err != nil {
+ return cfg.newErrInstance(nil, path, err)
+ }
+ if fi.IsDir() {
+ return cfg.newErrInstance(nil, path,
+ fmt.Errorf("%s is a directory, should be a CUE file", file))
+ }
+ fp.add(cfg.Dir, file, allowAnonymous)
+ }
+
+ // TODO: ModImportFromFiles(files)
+ _, err := filepath.Abs(cfg.Dir)
+ if err != nil {
+ return cfg.newErrInstance(nil, cfg.Dir, err)
+ }
+ pkg.Dir = cfg.Dir
+ rewriteFiles(pkg, pkg.Dir, true)
+ err = fp.finalize() // ImportDir(&ctxt, dir, 0)
+ // TODO: Support module importing.
+ // if ModDirImportPath != nil {
+ // // Use the effective import path of the directory
+ // // for deciding visibility during pkg.load.
+ // bp.ImportPath = ModDirImportPath(dir)
+ // }
+
+ for _, f := range pkg.CUEFiles {
+ if !filepath.IsAbs(f) {
+ f = filepath.Join(cfg.Dir, f)
+ }
+ pkg.AddFile(f, nil)
+ }
+
+ pkg.Local = true
+ l.stk.Push("user")
+ pkg.Complete()
+ l.stk.Pop()
+ pkg.Local = true
+ //pkg.LocalPrefix = dirToImportPath(dir)
+ pkg.DisplayPath = "command-line-arguments"
+ pkg.Match = files
+
+ return pkg
+}
+
+func cleanImport(path string) string {
+ orig := path
+ path = pathpkg.Clean(path)
+ if strings.HasPrefix(orig, "./") && path != ".." && !strings.HasPrefix(path, "../") {
+ path = "./" + path
+ }
+ return path
+}
+
+// An importStack is a stack of import paths, possibly with the suffix " (test)" appended.
+// The import path of a test package is the import path of the corresponding
+// non-test package with the suffix "_test" added.
+type importStack []string
+
+func (s *importStack) Push(p string) {
+ *s = append(*s, p)
+}
+
+func (s *importStack) Pop() {
+ *s = (*s)[0 : len(*s)-1]
+}
+
+func (s *importStack) Copy() []string {
+ return append([]string{}, *s...)
+}
+
+// shorterThan reports whether sp is shorter than t.
+// We use this to record the shortest import sequences
+// that leads to a particular package.
+func (sp *importStack) shorterThan(t []string) bool {
+ s := *sp
+ if len(s) != len(t) {
+ return len(s) < len(t)
+ }
+ // If they are the same length, settle ties using string ordering.
+ for i := range s {
+ if s[i] != t[i] {
+ return s[i] < t[i]
+ }
+ }
+ return false // they are equal
+}
+
+// reusePackage reuses package p to satisfy the import at the top
+// of the import stack stk. If this use causes an import loop,
+// reusePackage updates p's error information to record the loop.
+func (l *loader) reusePackage(p *build.Instance) *build.Instance {
+ // We use p.Internal.Imports==nil to detect a package that
+ // is in the midst of its own loadPackage call
+ // (all the recursion below happens before p.Internal.Imports gets set).
+ if p.ImportPaths == nil {
+ if err := lastError(p); err == nil {
+ err = l.errPkgf(nil, "import cycle not allowed")
+ err.IsImportCycle = true
+ report(p, err)
+ }
+ p.Incomplete = true
+ }
+ // Don't rewrite the import stack in the error if we have an import cycle.
+ // If we do, we'll lose the path that describes the cycle.
+ if err := lastError(p); err != nil && !err.IsImportCycle && l.stk.shorterThan(err.ImportStack) {
+ err.ImportStack = l.stk.Copy()
+ }
+ return p
+}
+
+// dirToImportPath returns the pseudo-import path we use for a package
+// outside the CUE path. It begins with _/ and then contains the full path
+// to the directory. If the package lives in c:\home\gopher\my\pkg then
+// the pseudo-import path is _/c_/home/gopher/my/pkg.
+// Using a pseudo-import path like this makes the ./ imports no longer
+// a special case, so that all the code to deal with ordinary imports works
+// automatically.
+func dirToImportPath(dir string) string {
+ return pathpkg.Join("_", strings.Map(makeImportValid, filepath.ToSlash(dir)))
+}
+
+func makeImportValid(r rune) rune {
+ // Should match Go spec, compilers, and ../../go/parser/parser.go:/isValidImport.
+ const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
+ if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
+ return '_'
+ }
+ return r
+}
diff --git a/cue/load/loader_test.go b/cue/load/loader_test.go
new file mode 100644
index 0000000..36effb6
--- /dev/null
+++ b/cue/load/loader_test.go
@@ -0,0 +1,116 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "testing"
+
+ build "cuelang.org/go/cue/build"
+ "cuelang.org/go/internal/str"
+)
+
+// TestLoad is an end-to-end test.
+func TestLoad(t *testing.T) {
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatal(err)
+ }
+ args := str.StringList
+ testCases := []struct {
+ args []string
+ want string
+ err string
+ }{{
+ args: nil,
+ want: "test: test.cue (1 files)",
+ }, {
+ args: args("."),
+ want: "test: test.cue (1 files)",
+ }, {
+ args: args("./other/..."),
+ want: `
+main: other/main.cue (1 files)
+ file: other/file/file.cue (1 files);main: other/main.cue (1 files)
+ file: other/file/file.cue (1 files)`,
+ }, {
+ args: args("./anon"),
+ want: ": (0 files)",
+ err: "build constraints exclude all CUE files",
+ }, {
+ args: args("./other"),
+ want: `
+main: other/main.cue (1 files)
+ file: other/file/file.cue (1 files)`,
+ }, {
+ args: args("./hello"),
+ want: "test: test.cue hello/test.cue (2 files)",
+ }, {
+ args: args("./anon.cue", "./other/anon.cue"),
+ want: ": ./anon.cue ./other/anon.cue (2 files)",
+ }, {
+ // Absolute file is normalized.
+ args: args(filepath.Join(cwd, "testdata", "anon.cue")),
+ want: ": ./anon.cue (1 files)",
+ }, {
+ args: args("non-existing"),
+ want: ": (0 files)",
+ err: `cannot find package "non-existing"`,
+ }, {
+ args: args("./empty"),
+ want: ": (0 files)",
+ err: `no CUE files in ./empty`,
+ }}
+ for i, tc := range testCases {
+ t.Run(strconv.Itoa(i)+"/"+strings.Join(tc.args, ":"), func(t *testing.T) {
+ c := &Config{Dir: filepath.Join(cwd, testdata)}
+ pkgs := Instances(tc.args, c)
+
+ var errs, data []string
+ for _, p := range pkgs {
+ if p.Err != nil {
+ errs = append(errs, p.Err.Error())
+ }
+ got := strings.TrimSpace(pkgInfo(pkgs[0]))
+ data = append(data, got)
+ }
+
+ if err := strings.Join(errs, ";"); err == "" != (tc.err == "") ||
+ err != "" && !strings.Contains(err, tc.err) {
+ t.Errorf("error:\n got: %v\nwant: %v", err, tc.err)
+ }
+ got := strings.Join(data, ";")
+ want := strings.TrimSpace(tc.want)
+ if got != want {
+ t.Errorf("got:\n%v\nwant:\n%v", got, want)
+ }
+ })
+ }
+}
+
+func pkgInfo(p *build.Instance) string {
+ b := &bytes.Buffer{}
+ fmt.Fprintf(b, "%s: %s (%d files)\n",
+ p.PkgName, strings.Join(p.CUEFiles, " "), len(p.Files))
+ for _, p := range p.Imports {
+ fmt.Fprintf(b, "\t%s\n", pkgInfo(p))
+ }
+ return b.String()
+}
diff --git a/cue/load/match.go b/cue/load/match.go
new file mode 100644
index 0000000..fb00fa6
--- /dev/null
+++ b/cue/load/match.go
@@ -0,0 +1,213 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "bytes"
+ "fmt"
+ "strings"
+ "unicode"
+)
+
+// matchFileTest reports whether the file with the given name in the given directory
+// matches the context and would be included in a Package created by ImportDir
+// of that directory.
+//
+// matchFileTest considers the name of the file and may use cfg.Build.OpenFile to
+// read some or all of the file's content.
+func matchFileTest(cfg *Config, dir, name string) (match bool, err error) {
+ match, _, _, err = matchFile(cfg, dir, name, false, false, nil)
+ return
+}
+
+// matchFile determines whether the file with the given name in the given directory
+// should be included in the package being constructed.
+// It returns the data read from the file.
+// If returnImports is true and name denotes a CUE file, matchFile reads
+// until the end of the imports (and returns that data) even though it only
+// considers text until the first non-comment.
+// If allTags is non-nil, matchFile records any encountered build tag
+// by setting allTags[tag] = true.
+func matchFile(cfg *Config, dir, name string, returnImports, allFiles bool, allTags map[string]bool) (match bool, data []byte, filename string, err error) {
+ if strings.HasPrefix(name, "_") ||
+ strings.HasPrefix(name, ".") {
+ return
+ }
+
+ i := strings.LastIndex(name, ".")
+ if i < 0 {
+ i = len(name)
+ }
+ ext := name[i:]
+
+ switch ext {
+ case cueSuffix:
+ // tentatively okay - read to make sure
+ default:
+ // skip
+ return
+ }
+
+ filename = cfg.fileSystem.joinPath(dir, name)
+ f, err := cfg.fileSystem.openFile(filename)
+ if err != nil {
+ return
+ }
+
+ if strings.HasSuffix(filename, cueSuffix) {
+ data, err = readImports(f, false, nil)
+ } else {
+ data, err = readComments(f)
+ }
+ f.Close()
+ if err != nil {
+ err = fmt.Errorf("read %s: %v", filename, err)
+ return
+ }
+
+ // Look for +build comments to accept or reject the file.
+ if !shouldBuild(cfg, data, allTags) && !allFiles {
+ return
+ }
+
+ match = true
+ return
+}
+
+// shouldBuild reports whether it is okay to use this file,
+// The rule is that in the file's leading run of // comments
+// and blank lines, which must be followed by a blank line
+// (to avoid including a Go package clause doc comment),
+// lines beginning with '// +build' are taken as build directives.
+//
+// The file is accepted only if each such line lists something
+// matching the file. For example:
+//
+// // +build windows linux
+//
+// marks the file as applicable only on Windows and Linux.
+//
+// If shouldBuild finds a //go:binary-only-package comment in the file,
+// it sets *binaryOnly to true. Otherwise it does not change *binaryOnly.
+//
+func shouldBuild(cfg *Config, content []byte, allTags map[string]bool) bool {
+ // Pass 1. Identify leading run of // comments and blank lines,
+ // which must be followed by a blank line.
+ end := 0
+ p := content
+ for len(p) > 0 {
+ line := p
+ if i := bytes.IndexByte(line, '\n'); i >= 0 {
+ line, p = line[:i], p[i+1:]
+ } else {
+ p = p[len(p):]
+ }
+ line = bytes.TrimSpace(line)
+ if len(line) == 0 { // Blank line
+ end = len(content) - len(p)
+ continue
+ }
+ if !bytes.HasPrefix(line, slashslash) { // Not comment line
+ break
+ }
+ }
+ content = content[:end]
+
+ // Pass 2. Process each line in the run.
+ p = content
+ allok := true
+ for len(p) > 0 {
+ line := p
+ if i := bytes.IndexByte(line, '\n'); i >= 0 {
+ line, p = line[:i], p[i+1:]
+ } else {
+ p = p[len(p):]
+ }
+ line = bytes.TrimSpace(line)
+ if bytes.HasPrefix(line, slashslash) {
+ line = bytes.TrimSpace(line[len(slashslash):])
+ if len(line) > 0 && line[0] == '+' {
+ // Looks like a comment +line.
+ f := strings.Fields(string(line))
+ if f[0] == "+build" {
+ ok := false
+ for _, tok := range f[1:] {
+ if doMatch(cfg, tok, allTags) {
+ ok = true
+ }
+ }
+ if !ok {
+ allok = false
+ }
+ }
+ }
+ }
+ }
+
+ return allok
+}
+
+// doMatch reports whether the name is one of:
+//
+// tag (if tag is listed in cfg.Build.BuildTags or cfg.Build.ReleaseTags)
+// !tag (if tag is not listed in cfg.Build.BuildTags or cfg.Build.ReleaseTags)
+// a comma-separated list of any of these
+//
+func doMatch(cfg *Config, name string, allTags map[string]bool) bool {
+ if name == "" {
+ if allTags != nil {
+ allTags[name] = true
+ }
+ return false
+ }
+ if i := strings.Index(name, ","); i >= 0 {
+ // comma-separated list
+ ok1 := doMatch(cfg, name[:i], allTags)
+ ok2 := doMatch(cfg, name[i+1:], allTags)
+ return ok1 && ok2
+ }
+ if strings.HasPrefix(name, "!!") { // bad syntax, reject always
+ return false
+ }
+ if strings.HasPrefix(name, "!") { // negation
+ return len(name) > 1 && !doMatch(cfg, name[1:], allTags)
+ }
+
+ if allTags != nil {
+ allTags[name] = true
+ }
+
+ // Tags must be letters, digits, underscores or dots.
+ // Unlike in CUE identifiers, all digits are fine (e.g., "386").
+ for _, c := range name {
+ if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
+ return false
+ }
+ }
+
+ // other tags
+ for _, tag := range cfg.BuildTags {
+ if tag == name {
+ return true
+ }
+ }
+ for _, tag := range cfg.releaseTags {
+ if tag == name {
+ return true
+ }
+ }
+
+ return false
+}
diff --git a/cue/load/match_test.go b/cue/load/match_test.go
new file mode 100644
index 0000000..3dbab93
--- /dev/null
+++ b/cue/load/match_test.go
@@ -0,0 +1,144 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "io"
+ "reflect"
+ "strings"
+ "testing"
+)
+
+func TestMatch(t *testing.T) {
+ c := &Config{}
+ what := "default"
+ matchFn := func(tag string, want map[string]bool) {
+ t.Helper()
+ m := make(map[string]bool)
+ if !doMatch(c, tag, m) {
+ t.Errorf("%s context should match %s, does not", what, tag)
+ }
+ if !reflect.DeepEqual(m, want) {
+ t.Errorf("%s tags = %v, want %v", tag, m, want)
+ }
+ }
+ noMatch := func(tag string, want map[string]bool) {
+ m := make(map[string]bool)
+ if doMatch(c, tag, m) {
+ t.Errorf("%s context should NOT match %s, does", what, tag)
+ }
+ if !reflect.DeepEqual(m, want) {
+ t.Errorf("%s tags = %v, want %v", tag, m, want)
+ }
+ }
+
+ c.BuildTags = []string{"foo"}
+ matchFn("foo", map[string]bool{"foo": true})
+ noMatch("!foo", map[string]bool{"foo": true})
+ matchFn("foo,!bar", map[string]bool{"foo": true, "bar": true})
+ noMatch("!", map[string]bool{})
+}
+
+func TestShouldBuild(t *testing.T) {
+ const file1 = "// +build tag1\n\n" +
+ "package main\n"
+ want1 := map[string]bool{"tag1": true}
+
+ const file2 = "// +build cgo\n\n" +
+ "// This package implements parsing of tags like\n" +
+ "// +build tag1\n" +
+ "package load"
+ want2 := map[string]bool{"cgo": true}
+
+ const file3 = "// Copyright The CUE Authors.\n\n" +
+ "package load\n\n" +
+ "// shouldBuild checks tags given by lines of the form\n" +
+ "// +build tag\n" +
+ "func shouldBuild(content []byte)\n"
+ want3 := map[string]bool{}
+
+ c := &Config{BuildTags: []string{"tag1"}}
+ m := map[string]bool{}
+ if !shouldBuild(c, []byte(file1), m) {
+ t.Errorf("shouldBuild(file1) = false, want true")
+ }
+ if !reflect.DeepEqual(m, want1) {
+ t.Errorf("shouldBuild(file1) tags = %v, want %v", m, want1)
+ }
+
+ m = map[string]bool{}
+ if shouldBuild(c, []byte(file2), m) {
+ t.Errorf("shouldBuild(file2) = true, want false")
+ }
+ if !reflect.DeepEqual(m, want2) {
+ t.Errorf("shouldBuild(file2) tags = %v, want %v", m, want2)
+ }
+
+ m = map[string]bool{}
+ c = &Config{BuildTags: nil}
+ if !shouldBuild(c, []byte(file3), m) {
+ t.Errorf("shouldBuild(file3) = false, want true")
+ }
+ if !reflect.DeepEqual(m, want3) {
+ t.Errorf("shouldBuild(file3) tags = %v, want %v", m, want3)
+ }
+}
+
+type readNopCloser struct {
+ io.Reader
+}
+
+func (r readNopCloser) Close() error {
+ return nil
+}
+
+var (
+ cfg = &Config{BuildTags: []string{"enable"}}
+ defCfg = &Config{}
+)
+
+var matchFileTests = []struct {
+ cfg *Config
+ name string
+ data string
+ match bool
+}{
+ {defCfg, "foo.cue", "", true},
+ {defCfg, "foo.cue", "// +build enable\n\npackage foo\n", false},
+ {defCfg, "foo.cue", "// +build !enable\n\npackage foo\n", true},
+ {defCfg, "foo1.cue", "// +build linux\n\npackage foo\n", false},
+ {defCfg, "foo.badsuffix", "", false},
+ {cfg, "foo.cue", "// +build enable\n\npackage foo\n", true},
+ {cfg, "foo.cue", "// +build !enable\n\npackage foo\n", false},
+}
+
+func TestMatchFile(t *testing.T) {
+ for _, tt := range matchFileTests {
+ ctxt := &tt.cfg.fileSystem
+ ctxt.OpenFile = func(path string) (r io.ReadCloser, err error) {
+ if path != "x+"+tt.name {
+ t.Fatalf("OpenFile asked for %q, expected %q", path, "x+"+tt.name)
+ }
+ return &readNopCloser{strings.NewReader(tt.data)}, nil
+ }
+ ctxt.JoinPath = func(elem ...string) string {
+ return strings.Join(elem, "+")
+ }
+ match, err := matchFileTest(tt.cfg, "x", tt.name)
+ if match != tt.match || err != nil {
+ t.Fatalf("MatchFile(%q) = %v, %v, want %v, nil", tt.name, match, err, tt.match)
+ }
+ }
+}
diff --git a/cue/load/package.go b/cue/load/package.go
new file mode 100644
index 0000000..ec817db
--- /dev/null
+++ b/cue/load/package.go
@@ -0,0 +1,68 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "unicode/utf8"
+
+ "cuelang.org/go/cue/build"
+ "cuelang.org/go/internal/str"
+)
+
+// Package rules:
+//
+// - the package clause defines a namespace.
+// - a cue file without a package clause is a standalone file.
+// - all files with the same package name within a directory and its
+// ancestor directories up to the package root belong to the same package.
+// - The package root is either the top of the file hierarchy or the first
+// directory in which a cue.mod file is defined.
+//
+// The contents of a namespace depends on the directory that is selected as the
+// starting point to load a package. An instance defines a package-directory
+// pair.
+
+// allFiles returns the names of all the files considered for the package.
+// This is used for sanity and security checks, so we include all files,
+// even IgnoredGoFiles, because some subcommands consider them.
+func allFiles(p *build.Instance) []string {
+ return str.StringList(
+ p.CUEFiles,
+ p.ToolCUEFiles,
+ p.TestCUEFiles,
+ p.IgnoredCUEFiles,
+ p.InvalidCUEFiles,
+ p.DataFiles,
+ )
+}
+
+var foldPath = make(map[string]string)
+
+// safeArg reports whether arg is a "safe" command-line argument,
+// meaning that when it appears in a command-line, it probably
+// doesn't have some special meaning other than its own name.
+// Obviously args beginning with - are not safe (they look like flags).
+// Less obviously, args beginning with @ are not safe (they look like
+// GNU binutils flagfile specifiers, sometimes called "response files").
+// To be conservative, we reject almost any arg beginning with non-alphanumeric ASCII.
+// We accept leading . _ and / as likely in file system paths.
+// There is a copy of this function in cmd/compile/internal/gc/noder.go.
+func safeArg(name string) bool {
+ if name == "" {
+ return false
+ }
+ c := name[0]
+ return '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || c == '.' || c == '_' || c == '/' || c >= utf8.RuneSelf
+}
diff --git a/cue/load/read.go b/cue/load/read.go
new file mode 100644
index 0000000..79f68b4
--- /dev/null
+++ b/cue/load/read.go
@@ -0,0 +1,257 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "bufio"
+ "errors"
+ "io"
+ "unicode/utf8"
+)
+
+type importReader struct {
+ b *bufio.Reader
+ buf []byte
+ peek byte
+ err error
+ eof bool
+ nerr int
+}
+
+func isIdent(c byte) bool {
+ return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '_' || c >= utf8.RuneSelf
+}
+
+var (
+ errSyntax = errors.New("syntax error")
+ errNUL = errors.New("unexpected NUL in input")
+)
+
+// syntaxError records a syntax error, but only if an I/O error has not already been recorded.
+func (r *importReader) syntaxError() {
+ if r.err == nil {
+ r.err = errSyntax
+ }
+}
+
+// readByte reads the next byte from the input, saves it in buf, and returns it.
+// If an error occurs, readByte records the error in r.err and returns 0.
+func (r *importReader) readByte() byte {
+ c, err := r.b.ReadByte()
+ if err == nil {
+ r.buf = append(r.buf, c)
+ if c == 0 {
+ err = errNUL
+ }
+ }
+ if err != nil {
+ if err == io.EOF {
+ r.eof = true
+ } else if r.err == nil {
+ r.err = err
+ }
+ c = 0
+ }
+ return c
+}
+
+// peekByte returns the next byte from the input reader but does not advance beyond it.
+// If skipSpace is set, peekByte skips leading spaces and comments.
+func (r *importReader) peekByte(skipSpace bool) byte {
+ if r.err != nil {
+ if r.nerr++; r.nerr > 10000 {
+ panic("go/build: import reader looping")
+ }
+ return 0
+ }
+
+ // Use r.peek as first input byte.
+ // Don't just return r.peek here: it might have been left by peekByte(false)
+ // and this might be peekByte(true).
+ c := r.peek
+ if c == 0 {
+ c = r.readByte()
+ }
+ for r.err == nil && !r.eof {
+ if skipSpace {
+ // For the purposes of this reader, semicolons are never necessary to
+ // understand the input and are treated as spaces.
+ switch c {
+ case ' ', '\f', '\t', '\r', '\n', ';':
+ c = r.readByte()
+ continue
+
+ case '/':
+ c = r.readByte()
+ if c == '/' {
+ for c != '\n' && r.err == nil && !r.eof {
+ c = r.readByte()
+ }
+ } else if c == '*' {
+ var c1 byte
+ for (c != '*' || c1 != '/') && r.err == nil {
+ if r.eof {
+ r.syntaxError()
+ }
+ c, c1 = c1, r.readByte()
+ }
+ } else {
+ r.syntaxError()
+ }
+ c = r.readByte()
+ continue
+ }
+ }
+ break
+ }
+ r.peek = c
+ return r.peek
+}
+
+// nextByte is like peekByte but advances beyond the returned byte.
+func (r *importReader) nextByte(skipSpace bool) byte {
+ c := r.peekByte(skipSpace)
+ r.peek = 0
+ return c
+}
+
+// readKeyword reads the given keyword from the input.
+// If the keyword is not present, readKeyword records a syntax error.
+func (r *importReader) readKeyword(kw string) {
+ r.peekByte(true)
+ for i := 0; i < len(kw); i++ {
+ if r.nextByte(false) != kw[i] {
+ r.syntaxError()
+ return
+ }
+ }
+ if isIdent(r.peekByte(false)) {
+ r.syntaxError()
+ }
+}
+
+// readIdent reads an identifier from the input.
+// If an identifier is not present, readIdent records a syntax error.
+func (r *importReader) readIdent() {
+ c := r.peekByte(true)
+ if !isIdent(c) {
+ r.syntaxError()
+ return
+ }
+ for isIdent(r.peekByte(false)) {
+ r.peek = 0
+ }
+}
+
+// readString reads a quoted string literal from the input.
+// If an identifier is not present, readString records a syntax error.
+func (r *importReader) readString(save *[]string) {
+ switch r.nextByte(true) {
+ case '`':
+ start := len(r.buf) - 1
+ for r.err == nil {
+ if r.nextByte(false) == '`' {
+ if save != nil {
+ *save = append(*save, string(r.buf[start:]))
+ }
+ break
+ }
+ if r.eof {
+ r.syntaxError()
+ }
+ }
+ case '"':
+ start := len(r.buf) - 1
+ for r.err == nil {
+ c := r.nextByte(false)
+ if c == '"' {
+ if save != nil {
+ *save = append(*save, string(r.buf[start:]))
+ }
+ break
+ }
+ if r.eof || c == '\n' {
+ r.syntaxError()
+ }
+ if c == '\\' {
+ r.nextByte(false)
+ }
+ }
+ default:
+ r.syntaxError()
+ }
+}
+
+// readImport reads an import clause - optional identifier followed by quoted string -
+// from the input.
+func (r *importReader) readImport(imports *[]string) {
+ c := r.peekByte(true)
+ if c == '.' {
+ r.peek = 0
+ } else if isIdent(c) {
+ r.readIdent()
+ }
+ r.readString(imports)
+}
+
+// readComments is like ioutil.ReadAll, except that it only reads the leading
+// block of comments in the file.
+func readComments(f io.Reader) ([]byte, error) {
+ r := &importReader{b: bufio.NewReader(f)}
+ r.peekByte(true)
+ if r.err == nil && !r.eof {
+ // Didn't reach EOF, so must have found a non-space byte. Remove it.
+ r.buf = r.buf[:len(r.buf)-1]
+ }
+ return r.buf, r.err
+}
+
+// readImports is like ioutil.ReadAll, except that it expects a Go file as input
+// and stops reading the input once the imports have completed.
+func readImports(f io.Reader, reportSyntaxError bool, imports *[]string) ([]byte, error) {
+ r := &importReader{b: bufio.NewReader(f)}
+
+ r.readKeyword("package")
+ r.readIdent()
+ for r.peekByte(true) == 'i' {
+ r.readKeyword("import")
+ if r.peekByte(true) == '(' {
+ r.nextByte(false)
+ for r.peekByte(true) != ')' && r.err == nil {
+ r.readImport(imports)
+ }
+ r.nextByte(false)
+ } else {
+ r.readImport(imports)
+ }
+ }
+
+ // If we stopped successfully before EOF, we read a byte that told us we were done.
+ // Return all but that last byte, which would cause a syntax error if we let it through.
+ if r.err == nil && !r.eof {
+ return r.buf[:len(r.buf)-1], nil
+ }
+
+ // If we stopped for a syntax error, consume the whole file so that
+ // we are sure we don't change the errors that go/parser returns.
+ if r.err == errSyntax && !reportSyntaxError {
+ r.err = nil
+ for r.err == nil && !r.eof {
+ r.readByte()
+ }
+ }
+
+ return r.buf, r.err
+}
diff --git a/cue/load/read_test.go b/cue/load/read_test.go
new file mode 100644
index 0000000..bb5004a
--- /dev/null
+++ b/cue/load/read_test.go
@@ -0,0 +1,236 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "io"
+ "strings"
+ "testing"
+)
+
+const quote = "`"
+
+type readTest struct {
+ // Test input contains ℙ where readImports should stop.
+ in string
+ err string
+}
+
+var readImportsTests = []readTest{
+ {
+ `package p`,
+ "",
+ },
+ {
+ `package p; import "x"`,
+ "",
+ },
+ {
+ `package p; import . "x"`,
+ "",
+ },
+ {
+ `package p; import "x";ℙvar x = 1`,
+ "",
+ },
+ {
+ `package p
+
+ // comment
+
+ import "x"
+ import _ "x"
+ import a "x"
+
+ /* comment */
+
+ import (
+ "x" /* comment */
+ _ "x"
+ a "x" // comment
+ ` + quote + `x` + quote + `
+ _ /*comment*/ ` + quote + `x` + quote + `
+ a ` + quote + `x` + quote + `
+ )
+ import (
+ )
+ import ()
+ import()import()import()
+ import();import();import()
+
+ ℙvar x = 1
+ `,
+ "",
+ },
+}
+
+var readCommentsTests = []readTest{
+ {
+ `ℙpackage p`,
+ "",
+ },
+ {
+ `ℙpackage p; import "x"`,
+ "",
+ },
+ {
+ `ℙpackage p; import . "x"`,
+ "",
+ },
+ {
+ `// foo
+
+ /* bar */
+
+ /* quux */ // baz
+
+ /*/ zot */
+
+ // asdf
+ ℙHello, world`,
+ "",
+ },
+}
+
+func testRead(t *testing.T, tests []readTest, read func(io.Reader) ([]byte, error)) {
+ for i, tt := range tests {
+ var in, testOut string
+ j := strings.Index(tt.in, "ℙ")
+ if j < 0 {
+ in = tt.in
+ testOut = tt.in
+ } else {
+ in = tt.in[:j] + tt.in[j+len("ℙ"):]
+ testOut = tt.in[:j]
+ }
+ r := strings.NewReader(in)
+ buf, err := read(r)
+ if err != nil {
+ if tt.err == "" {
+ t.Errorf("#%d: err=%q, expected success (%q)", i, err, string(buf))
+ continue
+ }
+ if !strings.Contains(err.Error(), tt.err) {
+ t.Errorf("#%d: err=%q, expected %q", i, err, tt.err)
+ continue
+ }
+ continue
+ }
+ if err == nil && tt.err != "" {
+ t.Errorf("#%d: success, expected %q", i, tt.err)
+ continue
+ }
+
+ out := string(buf)
+ if out != testOut {
+ t.Errorf("#%d: wrong output:\nhave %q\nwant %q\n", i, out, testOut)
+ }
+ }
+}
+
+func TestReadImports(t *testing.T) {
+ testRead(t, readImportsTests, func(r io.Reader) ([]byte, error) { return readImports(r, true, nil) })
+}
+
+func TestReadComments(t *testing.T) {
+ testRead(t, readCommentsTests, readComments)
+}
+
+var readFailuresTests = []readTest{
+ {
+ `package`,
+ "syntax error",
+ },
+ {
+ "package p\n\x00\nimport `math`\n",
+ "unexpected NUL in input",
+ },
+ {
+ `package p; import`,
+ "syntax error",
+ },
+ {
+ `package p; import "`,
+ "syntax error",
+ },
+ {
+ "package p; import ` \n\n",
+ "syntax error",
+ },
+ {
+ `package p; import "x`,
+ "syntax error",
+ },
+ {
+ `package p; import _`,
+ "syntax error",
+ },
+ {
+ `package p; import _ "`,
+ "syntax error",
+ },
+ {
+ `package p; import _ "x`,
+ "syntax error",
+ },
+ {
+ `package p; import .`,
+ "syntax error",
+ },
+ {
+ `package p; import . "`,
+ "syntax error",
+ },
+ {
+ `package p; import . "x`,
+ "syntax error",
+ },
+ {
+ `package p; import (`,
+ "syntax error",
+ },
+ {
+ `package p; import ("`,
+ "syntax error",
+ },
+ {
+ `package p; import ("x`,
+ "syntax error",
+ },
+ {
+ `package p; import ("x"`,
+ "syntax error",
+ },
+}
+
+func TestReadFailures(t *testing.T) {
+ // Errors should be reported (true arg to readImports).
+ testRead(t, readFailuresTests, func(r io.Reader) ([]byte, error) { return readImports(r, true, nil) })
+}
+
+func TestReadFailuresIgnored(t *testing.T) {
+ // Syntax errors should not be reported (false arg to readImports).
+ // Instead, entire file should be the output and no error.
+ // Convert tests not to return syntax errors.
+ tests := make([]readTest, len(readFailuresTests))
+ copy(tests, readFailuresTests)
+ for i := range tests {
+ tt := &tests[i]
+ if !strings.Contains(tt.err, "NUL") {
+ tt.err = ""
+ }
+ }
+ testRead(t, tests, func(r io.Reader) ([]byte, error) { return readImports(r, false, nil) })
+}
diff --git a/cue/load/search.go b/cue/load/search.go
new file mode 100644
index 0000000..ae11011
--- /dev/null
+++ b/cue/load/search.go
@@ -0,0 +1,497 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "fmt" // TODO: remove this usage
+ "log"
+ "os"
+ "path"
+ "path/filepath"
+ "regexp"
+ "strings"
+
+ build "cuelang.org/go/cue/build"
+)
+
+// A match represents the result of matching a single package pattern.
+type match struct {
+ Pattern string // the pattern itself
+ Literal bool // whether it is a literal (no wildcards)
+ Pkgs []*build.Instance
+ Err error
+}
+
+// TODO: should be matched from module file only.
+// The pattern is either "all" (all packages), "std" (standard packages),
+// "cmd" (standard commands), or a path including "...".
+func (l *loader) matchPackages(pattern string) *match {
+ // cfg := l.cfg
+ m := &match{
+ Pattern: pattern,
+ Literal: false,
+ }
+ // match := func(string) bool { return true }
+ // treeCanMatch := func(string) bool { return true }
+ // if !isMetaPackage(pattern) {
+ // match = matchPattern(pattern)
+ // treeCanMatch = treeCanMatchPattern(pattern)
+ // }
+
+ // have := map[string]bool{
+ // "builtin": true, // ignore pseudo-package that exists only for documentation
+ // }
+
+ // for _, src := range cfg.srcDirs() {
+ // if pattern == "std" || pattern == "cmd" {
+ // continue
+ // }
+ // src = filepath.Clean(src) + string(filepath.Separator)
+ // root := src
+ // if pattern == "cmd" {
+ // root += "cmd" + string(filepath.Separator)
+ // }
+ // filepath.Walk(root, func(path string, fi os.FileInfo, err error) error {
+ // if err != nil || path == src {
+ // return nil
+ // }
+
+ // want := true
+ // // Avoid .foo, _foo, and testdata directory trees.
+ // _, elem := filepath.Split(path)
+ // if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" {
+ // want = false
+ // }
+
+ // name := filepath.ToSlash(path[len(src):])
+ // if pattern == "std" && (!isStandardImportPath(name) || name == "cmd") {
+ // // The name "std" is only the standard library.
+ // // If the name is cmd, it's the root of the command tree.
+ // want = false
+ // }
+ // if !treeCanMatch(name) {
+ // want = false
+ // }
+
+ // if !fi.IsDir() {
+ // if fi.Mode()&os.ModeSymlink != 0 && want {
+ // if target, err := os.Stat(path); err == nil && target.IsDir() {
+ // fmt.Fprintf(os.Stderr, "warning: ignoring symlink %s\n", path)
+ // }
+ // }
+ // return nil
+ // }
+ // if !want {
+ // return filepath.SkipDir
+ // }
+
+ // if have[name] {
+ // return nil
+ // }
+ // have[name] = true
+ // if !match(name) {
+ // return nil
+ // }
+ // pkg := l.importPkg(".", path)
+ // if err := pkg.Error; err != nil {
+ // if _, noGo := err.(*noCUEError); noGo {
+ // return nil
+ // }
+ // }
+
+ // // If we are expanding "cmd", skip main
+ // // packages under cmd/vendor. At least as of
+ // // March, 2017, there is one there for the
+ // // vendored pprof tool.
+ // if pattern == "cmd" && strings.HasPrefix(pkg.DisplayPath, "cmd/vendor") && pkg.PkgName == "main" {
+ // return nil
+ // }
+
+ // m.Pkgs = append(m.Pkgs, pkg)
+ // return nil
+ // })
+ // }
+ return m
+}
+
+// matchPackagesInFS is like allPackages but is passed a pattern
+// beginning ./ or ../, meaning it should scan the tree rooted
+// at the given directory. There are ... in the pattern too.
+// (See go help packages for pattern syntax.)
+func (l *loader) matchPackagesInFS(pattern string) *match {
+ c := l.cfg
+ m := &match{
+ Pattern: pattern,
+ Literal: false,
+ }
+
+ // Find directory to begin the scan.
+ // Could be smarter but this one optimization
+ // is enough for now, since ... is usually at the
+ // end of a path.
+ i := strings.Index(pattern, "...")
+ dir, _ := path.Split(pattern[:i])
+
+ root := l.abs(dir)
+
+ if c.modRoot != "" {
+ if !hasFilepathPrefix(root, c.modRoot) {
+ m.Err = fmt.Errorf(
+ "cue: pattern %s refers to dir %s, outside module root %s",
+ pattern, root, c.modRoot)
+ return m
+ }
+ }
+
+ filepath.Walk(root, func(path string, fi os.FileInfo, err error) error {
+ if err != nil || !fi.IsDir() {
+ return nil
+ }
+
+ top := path == root
+
+ // Avoid .foo, _foo, and testdata directory trees, but do not avoid "." or "..".
+ _, elem := filepath.Split(path)
+ dot := strings.HasPrefix(elem, ".") && elem != "." && elem != ".."
+ if dot || strings.HasPrefix(elem, "_") || (elem == "testdata" && !top) {
+ return filepath.SkipDir
+ }
+
+ if !top {
+ // Ignore other modules found in subdirectories.
+ if _, err := os.Stat(filepath.Join(path, modFile)); err == nil {
+ return filepath.SkipDir
+ }
+ }
+
+ // name := prefix + filepath.ToSlash(path)
+ // if !match(name) {
+ // return nil
+ // }
+
+ // We keep the directory if we can import it, or if we can't import it
+ // due to invalid CUE source files. This means that directories
+ // containing parse errors will be built (and fail) instead of being
+ // silently skipped as not matching the pattern.
+ p := l.importPkg("."+path[len(root):], root)
+ if err := p.Err; err != nil && (p == nil || len(p.InvalidCUEFiles) == 0) {
+ switch err.(type) {
+ case nil:
+ break
+ case *noCUEError:
+ if c.DataFiles && len(p.DataFiles) > 0 {
+ break
+ }
+ return nil
+ default:
+ log.Print(err)
+ return nil
+ }
+ }
+
+ m.Pkgs = append(m.Pkgs, p)
+ return nil
+ })
+ return m
+}
+
+// treeCanMatchPattern(pattern)(name) reports whether
+// name or children of name can possibly match pattern.
+// Pattern is the same limited glob accepted by matchPattern.
+func treeCanMatchPattern(pattern string) func(name string) bool {
+ wildCard := false
+ if i := strings.Index(pattern, "..."); i >= 0 {
+ wildCard = true
+ pattern = pattern[:i]
+ }
+ return func(name string) bool {
+ return len(name) <= len(pattern) && hasPathPrefix(pattern, name) ||
+ wildCard && strings.HasPrefix(name, pattern)
+ }
+}
+
+// matchPattern(pattern)(name) reports whether
+// name matches pattern. Pattern is a limited glob
+// pattern in which '...' means 'any string' and there
+// is no other special syntax.
+// Unfortunately, there are two special cases. Quoting "go help packages":
+//
+// First, /... at the end of the pattern can match an empty string,
+// so that net/... matches both net and packages in its subdirectories, like net/http.
+// Second, any slash-separted pattern element containing a wildcard never
+// participates in a match of the "vendor" element in the path of a vendored
+// package, so that ./... does not match packages in subdirectories of
+// ./vendor or ./mycode/vendor, but ./vendor/... and ./mycode/vendor/... do.
+// Note, however, that a directory named vendor that itself contains code
+// is not a vendored package: cmd/vendor would be a command named vendor,
+// and the pattern cmd/... matches it.
+func matchPattern(pattern string) func(name string) bool {
+ // Convert pattern to regular expression.
+ // The strategy for the trailing /... is to nest it in an explicit ? expression.
+ // The strategy for the vendor exclusion is to change the unmatchable
+ // vendor strings to a disallowed code point (vendorChar) and to use
+ // "(anything but that codepoint)*" as the implementation of the ... wildcard.
+ // This is a bit complicated but the obvious alternative,
+ // namely a hand-written search like in most shell glob matchers,
+ // is too easy to make accidentally exponential.
+ // Using package regexp guarantees linear-time matching.
+
+ const vendorChar = "\x00"
+
+ if strings.Contains(pattern, vendorChar) {
+ return func(name string) bool { return false }
+ }
+
+ re := regexp.QuoteMeta(pattern)
+ re = replaceVendor(re, vendorChar)
+ switch {
+ case strings.HasSuffix(re, `/`+vendorChar+`/\.\.\.`):
+ re = strings.TrimSuffix(re, `/`+vendorChar+`/\.\.\.`) + `(/vendor|/` + vendorChar + `/\.\.\.)`
+ case re == vendorChar+`/\.\.\.`:
+ re = `(/vendor|/` + vendorChar + `/\.\.\.)`
+ case strings.HasSuffix(re, `/\.\.\.`):
+ re = strings.TrimSuffix(re, `/\.\.\.`) + `(/\.\.\.)?`
+ }
+ re = strings.Replace(re, `\.\.\.`, `[^`+vendorChar+`]*`, -1)
+
+ reg := regexp.MustCompile(`^` + re + `$`)
+
+ return func(name string) bool {
+ if strings.Contains(name, vendorChar) {
+ return false
+ }
+ return reg.MatchString(replaceVendor(name, vendorChar))
+ }
+}
+
+// replaceVendor returns the result of replacing
+// non-trailing vendor path elements in x with repl.
+func replaceVendor(x, repl string) string {
+ if !strings.Contains(x, "vendor") {
+ return x
+ }
+ elem := strings.Split(x, "/")
+ for i := 0; i < len(elem)-1; i++ {
+ if elem[i] == "vendor" {
+ elem[i] = repl
+ }
+ }
+ return strings.Join(elem, "/")
+}
+
+// warnUnmatched warns about patterns that didn't match any packages.
+func warnUnmatched(matches []*match) {
+ for _, m := range matches {
+ if len(m.Pkgs) == 0 {
+ m.Err =
+ fmt.Errorf("cue: %q matched no packages\n", m.Pattern)
+ }
+ }
+}
+
+// importPaths returns the matching paths to use for the given command line.
+// It calls ImportPathsQuiet and then WarnUnmatched.
+func (l *loader) importPaths(patterns []string) []*match {
+ matches := l.importPathsQuiet(patterns)
+ warnUnmatched(matches)
+ return matches
+}
+
+// importPathsQuiet is like ImportPaths but does not warn about patterns with no matches.
+func (l *loader) importPathsQuiet(patterns []string) []*match {
+ var out []*match
+ for _, a := range cleanPatterns(patterns) {
+ if isMetaPackage(a) {
+ out = append(out, l.matchPackages(a))
+ continue
+ }
+ if strings.Contains(a, "...") {
+ if isLocalImport(a) {
+ out = append(out, l.matchPackagesInFS(a))
+ } else {
+ out = append(out, l.matchPackages(a))
+ }
+ continue
+ }
+
+ pkg := l.importPkg(a, l.cfg.Dir)
+ out = append(out, &match{Pattern: a, Literal: true, Pkgs: []*build.Instance{pkg}})
+ }
+ return out
+}
+
+// cleanPatterns returns the patterns to use for the given
+// command line. It canonicalizes the patterns but does not
+// evaluate any matches.
+func cleanPatterns(patterns []string) []string {
+ if len(patterns) == 0 {
+ return []string{"."}
+ }
+ var out []string
+ for _, a := range patterns {
+ // Arguments are supposed to be import paths, but
+ // as a courtesy to Windows developers, rewrite \ to /
+ // in command-line arguments. Handles .\... and so on.
+ if filepath.Separator == '\\' {
+ a = strings.Replace(a, `\`, `/`, -1)
+ }
+
+ // Put argument in canonical form, but preserve leading ./.
+ if strings.HasPrefix(a, "./") {
+ a = "./" + path.Clean(a)
+ if a == "./." {
+ a = "."
+ }
+ } else {
+ a = path.Clean(a)
+ }
+ out = append(out, a)
+ }
+ return out
+}
+
+// isMetaPackage checks if name is a reserved package name that expands to multiple packages.
+func isMetaPackage(name string) bool {
+ return name == "std" || name == "cmd" || name == "all"
+}
+
+// hasPathPrefix reports whether the path s begins with the
+// elements in prefix.
+func hasPathPrefix(s, prefix string) bool {
+ switch {
+ default:
+ return false
+ case len(s) == len(prefix):
+ return s == prefix
+ case len(s) > len(prefix):
+ if prefix != "" && prefix[len(prefix)-1] == '/' {
+ return strings.HasPrefix(s, prefix)
+ }
+ return s[len(prefix)] == '/' && s[:len(prefix)] == prefix
+ }
+}
+
+// hasFilepathPrefix reports whether the path s begins with the
+// elements in prefix.
+func hasFilepathPrefix(s, prefix string) bool {
+ switch {
+ default:
+ return false
+ case len(s) == len(prefix):
+ return s == prefix
+ case len(s) > len(prefix):
+ if prefix != "" && prefix[len(prefix)-1] == filepath.Separator {
+ return strings.HasPrefix(s, prefix)
+ }
+ return s[len(prefix)] == filepath.Separator && s[:len(prefix)] == prefix
+ }
+}
+
+// isStandardImportPath reports whether $GOROOT/src/path should be considered
+// part of the standard distribution. For historical reasons we allow people to add
+// their own code to $GOROOT instead of using $GOPATH, but we assume that
+// code will start with a domain name (dot in the first element).
+//
+// Note that this function is meant to evaluate whether a directory found in GOROOT
+// should be treated as part of the standard library. It should not be used to decide
+// that a directory found in GOPATH should be rejected: directories in GOPATH
+// need not have dots in the first element, and they just take their chances
+// with future collisions in the standard library.
+func isStandardImportPath(path string) bool {
+ i := strings.Index(path, "/")
+ if i < 0 {
+ i = len(path)
+ }
+ elem := path[:i]
+ return !strings.Contains(elem, ".")
+}
+
+// isRelativePath reports whether pattern should be interpreted as a directory
+// path relative to the current directory, as opposed to a pattern matching
+// import paths.
+func isRelativePath(pattern string) bool {
+ return strings.HasPrefix(pattern, "./") || strings.HasPrefix(pattern, "../") || pattern == "." || pattern == ".."
+}
+
+// inDir checks whether path is in the file tree rooted at dir.
+// If so, inDir returns an equivalent path relative to dir.
+// If not, inDir returns an empty string.
+// inDir makes some effort to succeed even in the presence of symbolic links.
+// TODO(rsc): Replace internal/test.inDir with a call to this function for Go 1.12.
+func inDir(path, dir string) string {
+ if rel := inDirLex(path, dir); rel != "" {
+ return rel
+ }
+ xpath, err := filepath.EvalSymlinks(path)
+ if err != nil || xpath == path {
+ xpath = ""
+ } else {
+ if rel := inDirLex(xpath, dir); rel != "" {
+ return rel
+ }
+ }
+
+ xdir, err := filepath.EvalSymlinks(dir)
+ if err == nil && xdir != dir {
+ if rel := inDirLex(path, xdir); rel != "" {
+ return rel
+ }
+ if xpath != "" {
+ if rel := inDirLex(xpath, xdir); rel != "" {
+ return rel
+ }
+ }
+ }
+ return ""
+}
+
+// inDirLex is like inDir but only checks the lexical form of the file names.
+// It does not consider symbolic links.
+// TODO(rsc): This is a copy of str.HasFilePathPrefix, modified to
+// return the suffix. Most uses of str.HasFilePathPrefix should probably
+// be calling InDir instead.
+func inDirLex(path, dir string) string {
+ pv := strings.ToUpper(filepath.VolumeName(path))
+ dv := strings.ToUpper(filepath.VolumeName(dir))
+ path = path[len(pv):]
+ dir = dir[len(dv):]
+ switch {
+ default:
+ return ""
+ case pv != dv:
+ return ""
+ case len(path) == len(dir):
+ if path == dir {
+ return "."
+ }
+ return ""
+ case dir == "":
+ return path
+ case len(path) > len(dir):
+ if dir[len(dir)-1] == filepath.Separator {
+ if path[:len(dir)] == dir {
+ return path[len(dir):]
+ }
+ return ""
+ }
+ if path[len(dir)] == filepath.Separator && path[:len(dir)] == dir {
+ if len(path) == len(dir)+1 {
+ return "."
+ }
+ return path[len(dir)+1:]
+ }
+ return ""
+ }
+}
diff --git a/cue/load/search_test.go b/cue/load/search_test.go
new file mode 100644
index 0000000..3c83b8f
--- /dev/null
+++ b/cue/load/search_test.go
@@ -0,0 +1,175 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package load
+
+import (
+ "strings"
+ "testing"
+)
+
+var matchPatternTests = `
+ pattern ...
+ match foo
+
+ pattern net
+ match net
+ not net/http
+
+ pattern net/http
+ match net/http
+ not net
+
+ pattern net...
+ match net net/http netchan
+ not not/http not/net/http
+
+ # Special cases. Quoting docs:
+
+ # First, /... at the end of the pattern can match an empty string,
+ # so that net/... matches both net and packages in its subdirectories, like net/http.
+ pattern net/...
+ match net net/http
+ not not/http not/net/http netchan
+
+ # Second, any slash-separted pattern element containing a wildcard never
+ # participates in a match of the "vendor" element in the path of a vendored
+ # package, so that ./... does not match packages in subdirectories of
+ # ./vendor or ./mycode/vendor, but ./vendor/... and ./mycode/vendor/... do.
+ # Note, however, that a directory named vendor that itself contains code
+ # is not a vendored package: cmd/vendor would be a command named vendor,
+ # and the pattern cmd/... matches it.
+ pattern ./...
+ match ./vendor ./mycode/vendor
+ not ./vendor/foo ./mycode/vendor/foo
+
+ pattern ./vendor/...
+ match ./vendor/foo ./vendor/foo/vendor
+ not ./vendor/foo/vendor/bar
+
+ pattern mycode/vendor/...
+ match mycode/vendor mycode/vendor/foo mycode/vendor/foo/vendor
+ not mycode/vendor/foo/vendor/bar
+
+ pattern x/vendor/y
+ match x/vendor/y
+ not x/vendor
+
+ pattern x/vendor/y/...
+ match x/vendor/y x/vendor/y/z x/vendor/y/vendor x/vendor/y/z/vendor
+ not x/vendor/y/vendor/z
+
+ pattern .../vendor/...
+ match x/vendor/y x/vendor/y/z x/vendor/y/vendor x/vendor/y/z/vendor
+`
+
+func TestMatchPattern(t *testing.T) {
+ testPatterns(t, "MatchPattern", matchPatternTests, func(pattern, name string) bool {
+ return matchPattern(pattern)(name)
+ })
+}
+
+var treeCanMatchPatternTests = `
+ pattern ...
+ match foo
+
+ pattern net
+ match net
+ not net/http
+
+ pattern net/http
+ match net net/http
+
+ pattern net...
+ match net netchan net/http
+ not not/http not/net/http
+
+ pattern net/...
+ match net net/http
+ not not/http netchan
+
+ pattern abc.../def
+ match abcxyz
+ not xyzabc
+
+ pattern x/y/z/...
+ match x x/y x/y/z x/y/z/w
+
+ pattern x/y/z
+ match x x/y x/y/z
+ not x/y/z/w
+
+ pattern x/.../y/z
+ match x/a/b/c
+ not y/x/a/b/c
+`
+
+func TestTreeCanMatchPattern(t *testing.T) {
+ testPatterns(t, "TreeCanMatchPattern", treeCanMatchPatternTests, func(pattern, name string) bool {
+ return treeCanMatchPattern(pattern)(name)
+ })
+}
+
+var hasPathPrefixTests = []stringPairTest{
+ {"abc", "a", false},
+ {"a/bc", "a", true},
+ {"a", "a", true},
+ {"a/bc", "a/", true},
+}
+
+func TestHasPathPrefix(t *testing.T) {
+ testStringPairs(t, "hasPathPrefix", hasPathPrefixTests, hasPathPrefix)
+}
+
+type stringPairTest struct {
+ in1 string
+ in2 string
+ out bool
+}
+
+func testStringPairs(t *testing.T, name string, tests []stringPairTest, f func(string, string) bool) {
+ for _, tt := range tests {
+ if out := f(tt.in1, tt.in2); out != tt.out {
+ t.Errorf("%s(%q, %q) = %v, want %v", name, tt.in1, tt.in2, out, tt.out)
+ }
+ }
+}
+
+func testPatterns(t *testing.T, name, tests string, fn func(string, string) bool) {
+ var patterns []string
+ for _, line := range strings.Split(tests, "\n") {
+ if i := strings.Index(line, "#"); i >= 0 {
+ line = line[:i]
+ }
+ f := strings.Fields(line)
+ if len(f) == 0 {
+ continue
+ }
+ switch f[0] {
+ default:
+ t.Fatalf("unknown directive %q", f[0])
+ case "pattern":
+ patterns = f[1:]
+ case "match", "not":
+ want := f[0] == "match"
+ for _, pattern := range patterns {
+ for _, in := range f[1:] {
+ if fn(pattern, in) != want {
+ t.Errorf("%s(%q, %q) = %v, want %v", name, pattern, in, !want, want)
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/cue/load/test.cue b/cue/load/test.cue
new file mode 100644
index 0000000..3b90117
--- /dev/null
+++ b/cue/load/test.cue
@@ -0,0 +1,3 @@
+package test
+
+"Hello world!"
\ No newline at end of file
diff --git a/cue/load/testdata/anon.cue b/cue/load/testdata/anon.cue
new file mode 100644
index 0000000..e772705
--- /dev/null
+++ b/cue/load/testdata/anon.cue
@@ -0,0 +1 @@
+world: "World"
\ No newline at end of file
diff --git a/cue/load/testdata/anon/anon.cue b/cue/load/testdata/anon/anon.cue
new file mode 100644
index 0000000..e772705
--- /dev/null
+++ b/cue/load/testdata/anon/anon.cue
@@ -0,0 +1 @@
+world: "World"
\ No newline at end of file
diff --git a/cue/load/testdata/anon/dummy b/cue/load/testdata/anon/dummy
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/cue/load/testdata/anon/dummy
diff --git a/cue/load/testdata/cue.mod b/cue/load/testdata/cue.mod
new file mode 100644
index 0000000..b86175d
--- /dev/null
+++ b/cue/load/testdata/cue.mod
@@ -0,0 +1,14 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
diff --git a/cue/load/testdata/empty/dummy b/cue/load/testdata/empty/dummy
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/cue/load/testdata/empty/dummy
diff --git a/cue/load/testdata/hello/test.cue b/cue/load/testdata/hello/test.cue
new file mode 100644
index 0000000..3b90117
--- /dev/null
+++ b/cue/load/testdata/hello/test.cue
@@ -0,0 +1,3 @@
+package test
+
+"Hello world!"
\ No newline at end of file
diff --git a/cue/load/testdata/ignored/ignored.cue b/cue/load/testdata/ignored/ignored.cue
new file mode 100644
index 0000000..48a2ae8
--- /dev/null
+++ b/cue/load/testdata/ignored/ignored.cue
@@ -0,0 +1,3 @@
+// +build alwaysignore
+
+package ignored
diff --git a/cue/load/testdata/multi/file.cue b/cue/load/testdata/multi/file.cue
new file mode 100644
index 0000000..c5857fe
--- /dev/null
+++ b/cue/load/testdata/multi/file.cue
@@ -0,0 +1,5 @@
+// Test data - not compiled.
+
+package main
+
+{}
diff --git a/cue/load/testdata/multi/file_appengine.cue b/cue/load/testdata/multi/file_appengine.cue
new file mode 100644
index 0000000..9c95659
--- /dev/null
+++ b/cue/load/testdata/multi/file_appengine.cue
@@ -0,0 +1,5 @@
+// Test data - not compiled.
+
+package test_package
+
+{}
diff --git a/cue/load/testdata/other/anon.cue b/cue/load/testdata/other/anon.cue
new file mode 100644
index 0000000..42cf03d
--- /dev/null
+++ b/cue/load/testdata/other/anon.cue
@@ -0,0 +1,3 @@
+hello: "Hello \(world)"
+
+world: string
\ No newline at end of file
diff --git a/cue/load/testdata/other/file/file.cue b/cue/load/testdata/other/file/file.cue
new file mode 100644
index 0000000..57dcc90
--- /dev/null
+++ b/cue/load/testdata/other/file/file.cue
@@ -0,0 +1,5 @@
+// Test data - not compiled.
+
+package file
+
+{}
diff --git a/cue/load/testdata/other/main.cue b/cue/load/testdata/other/main.cue
new file mode 100644
index 0000000..923e89a
--- /dev/null
+++ b/cue/load/testdata/other/main.cue
@@ -0,0 +1,9 @@
+// Test data - not compiled.
+
+package main
+
+import (
+ "./file"
+)
+
+{}
\ No newline at end of file
diff --git a/cue/load/testdata/test.cue b/cue/load/testdata/test.cue
new file mode 100644
index 0000000..761254b
--- /dev/null
+++ b/cue/load/testdata/test.cue
@@ -0,0 +1 @@
+package test
\ No newline at end of file
